



Network Working Group                                           R. Abbas
Internet-Draft                                  Vacation Rental Protocol
Intended status: Informational                          15 November 2026
Expires: 19 May 2027


     The Vacation Rental Protocol (VRP): Host-Domain Discovery and
                   Verification of Signed Stay Offers
                 draft-abbas-vrp-offer-verification-00

Abstract

   The Vacation Rental Protocol (VRP) lets an AI agent or other client
   verify, directly from a vacation-rental host's own domain and with no
   intermediary, that a stay offer was signed by a key that domain
   publishes, has not been altered, and is within its stated lifetime.
   The signed offer carries the host domain's own statements of
   availability and exact price for the stay asked for.  A valid
   signature proves the provenance and integrity of those statements; it
   does not guarantee that the stay is in fact available.  A host domain
   publishes a discovery document at a well-known URI, an Ed25519 key
   set, and signed stay offers (compact JSON Web Signatures).
   Verification requires no central registry, issuer, accreditation
   program, or gatekeeper: control of the host domain is the root of
   trust.

   This document specifies the discovery document, key publication and
   rotation, the signed verified stay offer, and the verification
   procedure, including fail-closed behavior and a three-state
   verification model.  It also describes the existing provisional
   registration of the "vacation-rental.json" well-known URI suffix.

Status of This Memo

   This Internet-Draft is submitted in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at https://datatracker.ietf.org/drafts/current/.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."

   This Internet-Draft will expire on 19 May 2027.



Abbas                      Expires 19 May 2027                  [Page 1]

Internet-Draft           VRP Offer Verification            November 2026


Copyright Notice

   Copyright (c) 2026 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents (https://trustee.ietf.org/
   license-info) in effect on the date of publication of this document.
   Please review these documents carefully, as they describe your rights
   and restrictions with respect to this document.  Code Components
   extracted from this document must include Revised BSD License text as
   described in Section 4.e of the Trust Legal Provisions and are
   provided without warranty as described in the Revised BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3
     1.1.  Scope and Non-Goals . . . . . . . . . . . . . . . . . . .   3
   2.  Conventions and Terminology . . . . . . . . . . . . . . . . .   4
   3.  Discovery Document  . . . . . . . . . . . . . . . . . . . . .   4
     3.1.  Required Fields . . . . . . . . . . . . . . . . . . . . .   5
     3.2.  Host-Owned Domain . . . . . . . . . . . . . . . . . . . .   5
     3.3.  Node URL  . . . . . . . . . . . . . . . . . . . . . . . .   6
     3.4.  Fetching  . . . . . . . . . . . . . . . . . . . . . . . .   6
     3.5.  Recommended Fields  . . . . . . . . . . . . . . . . . . .   6
     3.6.  Trust Model of the Discovery Document . . . . . . . . . .   7
     3.7.  Transition Alias  . . . . . . . . . . . . . . . . . . . .   7
     3.8.  Node Page Identification  . . . . . . . . . . . . . . . .   7
   4.  Signing Keys (JWKS) . . . . . . . . . . . . . . . . . . . . .   8
     4.1.  Rotation  . . . . . . . . . . . . . . . . . . . . . . . .   8
     4.2.  Refresh on Miss . . . . . . . . . . . . . . . . . . . . .   9
     4.3.  Revocation and Cache Bound  . . . . . . . . . . . . . . .   9
   5.  Verified Stay Offer . . . . . . . . . . . . . . . . . . . . .  10
     5.1.  Offer Request . . . . . . . . . . . . . . . . . . . . . .  10
     5.2.  Signed Payload  . . . . . . . . . . . . . . . . . . . . .  10
     5.3.  Direct Booking URL  . . . . . . . . . . . . . . . . . . .  12
     5.4.  Computable Refund Schedule (Optional) . . . . . . . . . .  13
     5.5.  Reserved: Agent-Native Payment Rails  . . . . . . . . . .  14
   6.  Verification  . . . . . . . . . . . . . . . . . . . . . . . .  14
     6.1.  Freshness . . . . . . . . . . . . . . . . . . . . . . . .  14
     6.2.  Safe-to-Quote Rules . . . . . . . . . . . . . . . . . . .  15
     6.3.  Fail-Closed Behavior  . . . . . . . . . . . . . . . . . .  16
     6.4.  Three-State Verification  . . . . . . . . . . . . . . . .  16
     6.5.  Verifiability Classes . . . . . . . . . . . . . . . . . .  16
   7.  Security Considerations . . . . . . . . . . . . . . . . . . .  17
   8.  Privacy Considerations  . . . . . . . . . . . . . . . . . . .  19
   9.  IANA Considerations . . . . . . . . . . . . . . . . . . . . .  20
   10. References  . . . . . . . . . . . . . . . . . . . . . . . . .  20



Abbas                      Expires 19 May 2027                  [Page 2]

Internet-Draft           VRP Offer Verification            November 2026


     10.1.  Normative References . . . . . . . . . . . . . . . . . .  21
     10.2.  Informative References . . . . . . . . . . . . . . . . .  21
   Appendix A.  Example Discovery Document . . . . . . . . . . . . .  22
   Appendix B.  Example JWKS . . . . . . . . . . . . . . . . . . . .  23
   Appendix C.  Implementation Status  . . . . . . . . . . . . . . .  23
   Acknowledgements  . . . . . . . . . . . . . . . . . . . . . . . .  24
   Author's Address  . . . . . . . . . . . . . . . . . . . . . . . .  24

1.  Introduction

   When an AI agent or other client presents a vacation-rental stay
   offer to a guest, the guest relies on three things: that the offer
   comes from the host's own domain, that the price shown is the price
   that domain stated, and that the booking URL is on that domain.  This
   document specifies how a client checks each of the three.  A
   signature that verifies against the key set the host domain publishes
   shows that a key published by that domain signed exactly these terms,
   the price among them, and that they have not been altered.  Separate
   checks confirm that the offer names the domain whose discovery
   document the client fetched (Section 6.2) and that the booking URL is
   on that domain (Section 5.3).  A valid signature proves the
   provenance and integrity of those statements; it does not guarantee
   that the stay is in fact available.

   VRP does this for one concrete vertical, vacation rentals, with
   deliberately boring machinery: a well-known discovery document
   (Section 3), a published Ed25519 key set (Section 4), and stay offers
   signed as compact JSON Web Signatures over the host's own domain
   (Section 5).  A verifier fetches, verifies, and quotes - or fails
   closed (Section 6).

1.1.  Scope and Non-Goals

   VRP v0.1 defines how a host-owned vacation-rental domain publishes
   discovery metadata, signing keys, and signed verified stay offers so
   that clients can verify provenance, freshness, exact price, and the
   direct booking URL.

   VRP is not an online travel agency (OTA), marketplace, central
   registry, traffic proxy, payment processor, or central key issuer.
   VRP is a no-gatekeeper protocol: verification MUST NOT require any
   specific vendor, a VRP-operated trusted-issuer registry, a host
   accreditation program, a certification company, or a central
   discovery index.

   VRP may compose with adjacent agent-commerce standards for checkout,
   payment mandates, tool bindings, or inter-agent negotiation; those
   runtime flows are out of scope for this document.



Abbas                      Expires 19 May 2027                  [Page 3]

Internet-Draft           VRP Offer Verification            November 2026


2.  Conventions and Terminology

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
   "OPTIONAL" in this document are to be interpreted as described in BCP
   14 [RFC2119] [RFC8174] when, and only when, they appear in all
   capitals, as shown here.

   Node:  A host-owned HTTPS origin that publishes VRP resources.  Each
      node is one origin describing one vacation-rental site; there is
      no multi-publisher or shared-host case.

   Host domain:  The host-owned domain a node is served from
      (Section 3.2), carried as canonical_domain in VRP documents.

   Node URL:  An absolute https URL on the host domain or www. followed
      by it (Section 3.3).

   Discovery document:  The JSON resource at the node's well-known URI
      (Section 3).

   Verified stay offer:  A stay quote signed by the node as a compact
      JSON Web Signature (Section 5).

   Verifier:  An AI agent or other client that fetches and validates VRP
      resources.

   Quote:  Presenting an offer's price, availability, or booking URL to
      a user as host-verified information.

3.  Discovery Document

   A VRP node publishes a site-wide discovery document at:

   https://{host-domain}/.well-known/vacation-rental.json

   A client that already knows a host's domain issues this single
   request to discover that the origin is a bookable vacation-rental
   node and how to interact with it, in the site-wide pattern [RFC8615]
   is intended for.  The model mirrors other site-wide well-known
   configuration resources: probe one URL, receive a structured
   configuration, with no per-host hard-coding.

   *  Applicable scheme: https only.

   *  Media type: application/json [RFC8259].

   *  One origin per node.



Abbas                      Expires 19 May 2027                  [Page 4]

Internet-Draft           VRP Offer Verification            November 2026


3.1.  Required Fields

   protocol:  MUST be the string vacation-rental-protocol.

   protocol_version:  MUST be 0.1 for this version.

   canonical_domain:  MUST match the host-owned domain being verified,
      which is the domain this document is fetched from (Section 3.2).

   jwks_url:  MUST point to the host-domain JWKS (Section 4), and MUST
      be a node URL (Section 3.3).

   verified_stay_offer_endpoint:  MUST point to the host-domain verified
      stay offer endpoint (Section 5), and MUST be a node URL
      (Section 3.3).

3.2.  Host-Owned Domain

   A VRP node is a domain registered for the host, never a name under
   another party's domain.  canonical_domain MUST meet all of the
   following:

   1.  It is lowercase ASCII, with internationalized labels in A-label
       (xn--) form, and has no trailing dot.

   2.  It equals its own registrable domain as computed by the Public
       Suffix List algorithm [PSL] using only the rules in the list's
       ICANN section, each rule compared in A-label form; where no ICANN
       rule matches, the algorithm's default rule * applies.  The list's
       PRIVATE section does not count: it lists domains under which a
       company hands out names to its customers.

   3.  Its top-level domain is not a brand or closed top-level domain,
       under which every name belongs to the top-level domain's
       operator.  These are: every top-level domain whose ICANN registry
       agreement includes Specification 13, marked "specification13":
       true in ICANN's gTLD list [ICANN-GTLDS]; and booking and hotels,
       whose registry operator is Booking.com B.V.  This list changes
       only by a recorded decision of the specification's maintainers.

   A name under a platform, catalog, marketplace, OTA, site builder or
   operator domain is never a canonical_domain, whoever operates that
   domain.  example.com and example.co.uk are host-owned domains;
   www.example.com, villa.platform.example, villa.booking and
   villa.amazon are not.  A verifier that holds no copy of the ICANN
   section of the Public Suffix List, or of ICANN's gTLD list, MUST
   treat the node as unknown (Section 6.4).




Abbas                      Expires 19 May 2027                  [Page 5]

Internet-Draft           VRP Offer Verification            November 2026


3.3.  Node URL

   A node URL is an absolute https URL whose host is canonical_domain or
   www. followed by canonical_domain, with no userinfo (no user name or
   password) and no port other than the https default.  Hosts are
   compared after URL parsing, which lowercases them.

3.4.  Fetching

   The domain a discovery document, a JWKS or an offer is fetched from
   is the host of the URL the verifier requested.  A verifier requests
   the discovery document at https://{domain}/.well-known/vacation-
   rental.json for the domain it is verifying, which the document's
   canonical_domain then has to match.  A verifier MAY follow a redirect
   only when its target is a node URL of that domain; it MUST NOT follow
   any other redirect, and MUST treat what it would have fetched as
   unknown (Section 6.4).

3.5.  Recommended Fields

   A node SHOULD also publish:

   node_id:  A stable node identifier.

   capabilities:  Supported operations (for example
      signed_verified_stay_offer, live_availability, exact_total_price,
      direct_booking_url).

   endpoints:  Additional operation URLs.

   operator:  MAY carry name, role, and key_custody.  key_custody
      declares who holds the node's Ed25519 signing key: platform (an
      operator holds and operates the key on the host's behalf - offers
      are signed under the host's domain identity and remain
      independently verifiable against jwks_url, but the host does not
      hold the key itself) or self (the host self-custodies the key).
      When the field is absent, custody is unspecified, and a verifier
      MUST NOT assume self-custody.  This lets a verifier reason about
      exactly what a valid signature guarantees: provenance and
      integrity in both cases, host self-sovereignty only when self.

   Clients MUST ignore unknown fields.









Abbas                      Expires 19 May 2027                  [Page 6]

Internet-Draft           VRP Offer Verification            November 2026


3.6.  Trust Model of the Discovery Document

   Trust is not derived from the well-known location; presence at the
   well-known URI confers no authority.  Authoritative offers are signed
   on the host's own domain and verify standalone against the node's
   published keys, independent of any central party.  A client SHOULD
   verify signatures and MUST NOT treat the discovery document itself as
   proof of any claim: the document is advisory metadata only.

3.7.  Transition Alias

   For transition compatibility a node MAY additionally serve the same
   document at the longer alias path /.well-known/vacation-rental-
   protocol.json.  Clients SHOULD use vacation-rental.json.

3.8.  Node Page Identification

   A VRP node is found and verified through its discovery document and
   its signed offers.  The pages a guest or an AI model reads are not
   part of that chain.  The rules below make the protocol visible there
   too.  In this version they are SHOULD; (a) and (b) are intended to
   become MUST in the next major version, the migration path being these
   two tags.  For the page served at https://{canonical_domain}/:

   (a)  The document head SHOULD contain <link rel="protocol"
        href="https://vacationrentalprotocol.com/">.

   (b)  The document body SHOULD contain a visible hyperlink carrying
        rel="protocol" whose href is on the origin
        https://vacationrentalprotocol.com (the root, or
        /verify?host={canonical_domain}) and whose link text contains
        the string VRP.

   (c)  The response SHOULD carry the HTTP header Link:
        <https://vacationrentalprotocol.com/>;
        rel="https://vacationrentalprotocol.com/rel/protocol".

   (d)  schema.org JSON-LD on the page SHOULD mark the lodging with
        "additionalType": "https://vacationrentalprotocol.com/
        terms#VRPVacationRental".

   (e)  The page SHOULD describe the property as a VRP vacation rental
        in its own language.








Abbas                      Expires 19 May 2027                  [Page 7]

Internet-Draft           VRP Offer Verification            November 2026


   The href in (a) and (b) MUST NOT point to an implementation, an
   operator, or any origin other than
   https://vacationrentalprotocol.com: the link names the standard,
   never a vendor.  The HTML keyword protocol and the extension relation
   type https://vacationrentalprotocol.com/rel/protocol denote the same
   relation.

4.  Signing Keys (JWKS)

   A VRP node publishes an Ed25519 public key set [RFC7517] at:

   https://{host-domain}/.well-known/jwks.json

   Keys used for signing verified stay offers MUST use [RFC8037]:

   *  kty: OKP

   *  crv: Ed25519

   *  alg: EdDSA

   *  kid: stable key identifier

   *  x: base64url-encoded Ed25519 public key

   Such keys SHOULD also set use to sig and include verify in key_ops.

   Because there is no central issuer, the JWKS is the only revocation
   authority: a key is valid exactly while it appears in the node's
   JWKS.

4.1.  Rotation

   To rotate, a node MUST publish the new key alongside the old one in
   its JWKS and sign new offers with the new key's kid.  It SHOULD
   retain the old key in the JWKS until every offer signed with it has
   passed its valid_until, so the retention overlap equals the maximum
   offer lifetime.  A node SHOULD use a kid that encodes a date and
   sequence (for example example.com-2026-05-18-01) so operators can
   order keys; a verifier MUST treat kid as opaque and MUST NOT infer
   trust, recency, or status from its value.










Abbas                      Expires 19 May 2027                  [Page 8]

Internet-Draft           VRP Offer Verification            November 2026


4.2.  Refresh on Miss

   If a verifier receives an offer whose kid is not present in its
   cached JWKS, it MUST re-fetch the node's JWKS before acting, and only
   treat the offer as unverifiable if the kid is still absent.  This
   makes a rotation take effect immediately and decouples rotation from
   the cache bound below, so the cache bound governs revocation latency
   alone.  To avoid amplification, a verifier SHOULD rate-limit or
   coalesce refresh-on-miss per domain, so a stream of offers bearing
   unknown kids cannot drive it into excessive JWKS fetches against the
   node.

4.3.  Revocation and Cache Bound

   A key's presence in the JWKS is the entire trust signal: an offer
   verifies only against a key that is in the JWKS now.  Removing a key
   makes every offer signed with it unverifiable, regardless of when it
   was signed; there is no retroactive "historically valid" exemption.

   *  Routine rotation avoids breakage through timing: retain the
      outgoing key until its outstanding offers have passed valid_until,
      then remove it.

   *  Compromise requires immediate removal.  This also invalidates the
      operator's own legitimate offers signed with that key -
      intentionally, because a verifier cannot distinguish the
      operator's offers from an attacker's when they share the same key.
      Legitimate stays are re-signed with the new key.

   Offer freshness (Section 6.1) does not bound a compromise: an
   attacker holding the leaked private key can mint fresh offers with a
   future valid_until.  The only thing that stops a conforming verifier
   from honoring them is the key being absent from the JWKS it holds.
   Therefore:

   *  A verifier MUST NOT cache a node's JWKS for longer than 5 minutes.
      A node's Cache-Control [RFC9111] may only shorten this window,
      never extend it.  This bound is the revocation latency: a
      compromised key is fully de-trusted by conforming verifiers within
      the cache window after it is removed from the JWKS.

   *  A node SHOULD serve jwks.json with a short Cache-Control (for
      example max-age=300 or less).  The JWKS is a small, CDN-cacheable
      document, so frequent re-fetching is inexpensive.







Abbas                      Expires 19 May 2027                  [Page 9]

Internet-Draft           VRP Offer Verification            November 2026


   Three distinct controls, not to be conflated: freshness (valid_until)
   bounds how long an offer is quotable; refresh-on-miss gives immediate
   discovery of the current key set (rotation); the JWKS cache cap
   bounds how long a revoked key is still accepted (revocation latency).
   They are independent - none substitutes for another.

5.  Verified Stay Offer

5.1.  Offer Request

   The verified stay offer endpoint accepts at least:

   check_in:  Arrival date, YYYY-MM-DD.

   check_out:  Departure date, YYYY-MM-DD.

   guests:  Integer guest count.

   The endpoint returns a signed verified stay offer envelope; the
   signed payload contains the quotable facts.

5.2.  Signed Payload

   The signature format is compact JWS [RFC7515] using EdDSA over an
   Ed25519 key published in the host-domain JWKS.  The signed payload
   MUST include:

   *  kind: the string verified_stay_offer
   *  protocol_version: 0.1
   *  canonical_domain
   *  node_id
   *  generated_at
   *  valid_until
   *  request (the echoed stay parameters)
   *  property
   *  availability
   *  price
   *  booking
   *  agent_permission

   The stay asked for.  request is the stay the offer is for, as it was
   asked for at the offer endpoint (Section 5.1): check_in and check_out
   are dates in YYYY-MM-DD form, and guests is an integer of at least 1.

   *  check_in and check_out MUST be dates that exist in the calendar
      ([RFC3339] full-date), and check_out MUST be later than check_in.





Abbas                      Expires 19 May 2027                 [Page 10]

Internet-Draft           VRP Offer Verification            November 2026


   *  A node MUST NOT sign an offer for dates that break these rules, or
      whose check_in is earlier than the current date at the property.
      It answers with an error instead.

   *  check_in, check_out, guests and language are the requester's
      words, echoed back; they are not statements by the host.
      check_in_weekday, check_out_weekday and nights, when present, are
      the node's own, computed from the two dates.  A node MUST NOT copy
      into the signed payload any value from the request other than
      those four.  request.language, when present, MUST be a BCP 47
      [RFC5646] language tag made of a language subtag (two or three
      letters), optionally a script subtag (four letters) and optionally
      a region subtag (two letters or three digits), joined by hyphens;
      letter case does not matter, as in BCP 47.  It SHOULD name a
      language the node writes the offer in.

   Lifetime.  generated_at and valid_until are UTC date-times ([RFC3339]
   date-time, ending in Z).  A node MUST set generated_at to the time it
   signs the offer.  valid_until MUST be later than generated_at and
   MUST NOT be more than 900 seconds (15 minutes) after it.  The two
   values are compared as written, fractions of a second included.

   The signed payload MAY also include host-verified direct-source
   facts, so that a verifier can verify (not just read) the node's
   commercial positioning:

   source_authority:  model: host_verified_direct_source,
      is_official_source_for_property, intermediary: none,
      payment_recipient: host, booking_model: direct_with_host,
      booking_commission_pct: 0.  A reselling marketplace cannot
      truthfully sign these.

   price.no_add_on_fees:  true asserts the quoted total has no add-on
      booking, service, or cleaning fees (the displayed price is the
      total paid).  This describes the node's own fee structure and is
      never a comparison with any other channel.

   price.minor_unit:  The unit of every amount in price (public_total,
      agent_total, total, each breakdown[].nightly_rate, each
      adjustments[].amount, the reconciliation sums).  true: integers in
      the currency's minor unit (cents): 29100 is 291.00 EUR.  false:
      whole currency units: 8930 is 8 930 SEK.  The offer schema of this
      protocol version [VRP-SPEC] requires the flag, and it applies to
      the whole price object; a consumer reads it before it quotes,
      converts or displays an amount.






Abbas                      Expires 19 May 2027                 [Page 11]

Internet-Draft           VRP Offer Verification            November 2026


5.3.  Direct Booking URL

   The signed payload's booking object carries the direct booking URL
   the verifier routes the user to, and MUST include direct_booking_url.
   It is the only booking action a VRP verifier may take for the offer
   (Section 6.2).

   Structure:

   *  direct_booking_url MUST be an absolute https URL.

   *  Its host MUST be the offer's canonical_domain, or www. followed by
      it, and no other name, with no userinfo and no port other than the
      https default.  It MUST NOT point at any other host: another name
      under the node's domain, another node's domain, a name under a
      platform, catalog, marketplace or operator domain, an OTA, a link
      shortener or a redirector.  A verifier that cannot confirm that it
      is a node URL (Section 3.3) MUST treat the direct booking URL as
      unknown (Section 6.4) and MUST NOT route booking to it.

   *  The URL SHOULD encode the quoted stay so the booking page opens
      pre-filled for the same stay.  The RECOMMENDED query parameters
      are checkIn (YYYY-MM-DD, matching request.check_in), checkOut
      (YYYY-MM-DD, matching request.check_out), and guests (integer,
      matching request.guests).

   *  The URL MAY include an offer reference identifier (for example an
      offer query parameter) so the node can correlate the click with
      the signed offer it issued.  The reference identifier, when
      present, MUST NOT be required by a verifier to validate the offer
      and MUST NOT be treated as a substitute for verifying the JWS
      signature.

   *  The URL MAY include additional host-specific query parameters.  A
      verifier MUST ignore unrecognized query parameters and MUST NOT
      treat their presence as a verification failure.

   Integrity: direct_booking_url is a field inside the signed offer
   payload.  Its integrity derives solely from the compact JWS over that
   payload: if the JWS verifies against the host-domain JWKS, the direct
   booking URL is exactly the URL the host signed.  There is no separate
   signature over the URL, and a verifier MUST NOT accept a
   direct_booking_url delivered outside, or modified after, the signed
   payload.  A direct_booking_url whose enclosing offer fails signature
   verification is unknown and MUST NOT be used.

   Lifecycle: the direct booking URL is actionable only while the
   enclosing offer is fresh, that is, while valid_until holds:



Abbas                      Expires 19 May 2027                 [Page 12]

Internet-Draft           VRP Offer Verification            November 2026


   *  While the offer is fresh, a verifier MAY present and route the
      user to direct_booking_url subject to the safe-to-quote rules
      (Section 6.2).

   *  Once valid_until has passed, the offer is stale.  The verifier
      MUST treat the direct booking URL as unknown and MUST NOT present
      its associated price as current or claim the stay is bookable on
      the strength of the stale offer.  The verifier SHOULD fetch a
      fresh signed offer for the user's dates and guest count before
      routing a booking action.

   *  After expiry, the host node MAY continue to serve the same URL,
      MAY re-quote (return a new signed offer, which may carry a
      different price, availability, or direct_booking_url), or MAY
      return an unavailable or non-quotable offer.  Following an expired
      direct_booking_url is therefore an unverified action: the host,
      not the protocol, decides what the URL does after expiry.

   *  A host node SHOULD ensure that following direct_booking_url after
      expiry fails closed for the guest - for example by re-quoting on
      the landing page rather than silently honoring a stale price.  VRP
      does not guarantee that a price observed in an expired offer is
      still available.

5.4.  Computable Refund Schedule (Optional)

   A node MAY publish its cancellation refund terms inside the signed
   offer as rules.refund_schedule: an array of rows {
   "hours_before_checkin": n, "refund_percent": p } with n a non-
   negative integer and p an integer from 0 to 100.

   The schedule is computable, not descriptive.  A verifier evaluates it
   as a pure predicate with no platform context:

   1.  Compute H = floor((check-in moment - cancellation time) / 1
       hour): whole hours, floored.  Flooring makes fractional
       boundaries resolve in the node's favor; implementations MUST NOT
       substitute other rounding.

   2.  Sort rows by hours_before_checkin descending.  The first row with
       hours_before_checkin <= H applies; the guest receives that row's
       refund_percent of the paid total.

   3.  No matching row - including any cancellation after the check-in
       moment, where H is negative - means 0 percent.






Abbas                      Expires 19 May 2027                 [Page 13]

Internet-Draft           VRP Offer Verification            November 2026


   A row with hours_before_checkin: 0 therefore means "this percent up
   to the check-in moment itself".  An empty array is a valid, honest
   schedule meaning "no refund at any point".  An absent or null field
   means the node has not published computable terms: the answer is
   unknown, and a verifier MUST NOT invent, infer, or default a refund
   promise.

   Because the schedule is signed inside the offer, it is verifiable,
   not merely attested: the guest's agent can prove after the fact
   exactly which refund terms were in force at quote time, regardless of
   what the node's pages say later.  Nodes and verifiers MUST relay the
   rows verbatim to guests - as hours/percent terms, never re-labelled
   into named tiers ("flexible", "moderate", and similar), which this
   field replaces.

5.5.  Reserved: Agent-Native Payment Rails

   VRP v0.1 defines exactly one payment path: direct_booking_url,
   settled by the host's own payment processor.  The optional
   booking.payment_options field is reserved for a future agent-native
   payment-rail binding and is not defined in v0.1: its shape,
   settlement, refund handling, and reconciliation are intentionally
   left open.  A node SHOULD omit it; a verifier MUST NOT treat its
   presence as a defined, honorable payment path.

   Two invariants will hold whenever the binding is defined, and
   constrain it now: the payee is the host's own (never an intermediary
   or marketplace), and payment rails MUST NOT gate discovery,
   verification, or offer retrieval (Section 1.1).

6.  Verification

6.1.  Freshness

   Verifiers MUST treat an offer as non-quotable if valid_until is
   missing, malformed, or expired.

   Verifiers MUST also treat an offer as non-quotable if generated_at is
   missing or malformed, if generated_at is more than 60 seconds later
   than the verifier's current time, or if valid_until is not later than
   generated_at or is more than 900 seconds after it (Section 5.2).  The
   60 seconds allow for clocks that are not exactly in step; they do not
   lengthen the lifetime.

   Verifiers SHOULD fetch a fresh offer for the user's specific dates
   and guest count before presenting a final price or booking URL.





Abbas                      Expires 19 May 2027                 [Page 14]

Internet-Draft           VRP Offer Verification            November 2026


6.2.  Safe-to-Quote Rules

   A verifier MUST NOT quote an offer as an official host-domain
   verified offer unless all of the following are true:

   *  The discovery document is fetched from the host-owned domain
      (Section 3.2), and its canonical_domain is that domain.
   *  The discovery document declares protocol: "vacation-rental-
      protocol".
   *  The discovery document declares protocol_version: "0.1".
   *  The JWKS contains an Ed25519 verification key matching the JWS.
   *  The compact JWS verifies against the host-domain JWKS.
   *  The signed payload matches the returned offer.
   *  The signed payload's canonical_domain is the domain the discovery
      document was fetched from.
   *  valid_until is present and fresh.
   *  generated_at and valid_until meet Section 5.2 and Section 6.1:
      valid_until is later than generated_at and at most 900 seconds
      after it, and generated_at is not more than 60 seconds later than
      the verifier's current time.
   *  request.check_in and request.check_out are dates that exist,
      request.check_out is later than request.check_in, and
      request.check_in is not earlier than the day before the verifier's
      current date in UTC.  The local date anywhere is at most one day
      behind the UTC date, so a check_in earlier than that has passed
      everywhere; the node itself applies the property's own date
      (Section 5.2).
   *  request.check_in, request.check_out and request.guests are the
      dates and the guest count the verifier asked for.
   *  request.language, when present, has the form Section 5.2 gives.
   *  availability.available is true.
   *  price.exact is true.
   *  A direct booking URL is present.
   *  agent_permission.may_quote_as_official_direct_offer is true.

   Verifiers MUST NOT:

   *  Invent discounts, savings, promo codes, OTA comparisons, or price
      reductions.
   *  Say the stay is bookable unless availability.available is true and
      agent permission allows quoting.
   *  Quote a final total unless price.exact is true in the signed
      offer.
   *  Route booking action anywhere except the signed direct booking
      URL.
   *  Present a value from request as something the host stated
      (Section 5.2).




Abbas                      Expires 19 May 2027                 [Page 15]

Internet-Draft           VRP Offer Verification            November 2026


6.3.  Fail-Closed Behavior

   Verifiers and clients MUST fail closed.  If signature verification,
   the offer's binding to the fetched domain and to the stay asked for
   (Section 6.2), freshness and lifetime (Section 5.2, Section 6.1), the
   dates, exact price, availability, the direct booking URL, or citation
   permission cannot be verified, the offer MUST NOT be quoted as
   official or bookable.

6.4.  Three-State Verification

   Verifiers and clients interacting with VRP nodes MUST distinguish
   three states for any required endpoint or field:

   Affirmed:  Present, signed where required, fresh, schema-valid, and
      explicitly true or present.  May be cited.

   Negated:  Present, signed where required, fresh, schema-valid, and
      explicitly false.  May be cited as false.

   Unknown:  Absent, unsigned, stale, unreachable, schema-invalid,
      malformed, expired, or otherwise unverifiable.  MUST NOT be cited
      as true or false.

   Unreachable is not the same as negated.  A timeout, DNS failure, HTTP
   failure, blocked fetch, invalid JSON, missing field, failed signature
   check, stale valid_until, or schema mismatch means unknown.
   Inference from unknown to either affirmed or negated is a protocol
   violation.  Verifiers SHOULD tell the user that the value could not
   be verified and fetch a fresh signed offer before making booking,
   availability, price, or official-source claims.

6.5.  Verifiability Classes

   VRP data falls into exactly three classes, and a surface MUST NOT
   present a lower class as a higher one:

   Verifiable:  Fields signed inside the offer's compact JWS: price
      (including exact and no_add_on_fees), availability, valid_until,
      source_authority, and rules.refund_schedule.  Tampering with any
      of them invalidates the same signature.

   Attested:  Host-declared tri-state claims (amenities, policies)








Abbas                      Expires 19 May 2027                 [Page 16]

Internet-Draft           VRP Offer Verification            November 2026


      published in the node's discovery document and optionally as a
      VRPPropertyAttestedClaimsCredential (defined in Section 5.5 of the
      portable attestations specification in the protocol repository
      [VRP-SPEC]).  Actionable as the host's explicit statement -
      including negations ("cats are not allowed") - but not
      cryptographically bound to a specific purchase moment.  Absence is
      unknown, never a yes or a no.

   Reputational:  Review aggregates, stay history, and similar evidence
      about past experience.  A verifier MAY cite it (accurately
      attributed and time-bounded) but MUST NOT present it as a promise,
      a term, or a fact about the current offer.

   Determining the class of a field is mechanical, never editorial: the
   class follows from where the value was read, not from how any surface
   phrases it.  Read from inside the offer JWS payload (after signature
   verification): verifiable.  Read from the discovery document's claims
   or an attestation credential: attested.  Read from review data:
   reputational.  A value that appears in more than one place carries
   the class of the surface it was actually read from: reading an
   amenity from the discovery document never inherits the offer's
   signature, even when the same value also happens to appear inside a
   signed offer.  If a host asserts something outside the signed payload
   - in prose, marketing copy, or an unsigned field - a renderer MUST
   treat it as attested at best, regardless of wording: language like
   "verified", "guaranteed", or "signed" attached to an unsigned value
   is a class violation, not a promotion.

7.  Security Considerations

   Root of trust.  The root of trust is control of the host domain: the
   key set is whatever the host domain serves.  Rotation and revocation
   (Section 4) protect the case where a signing key leaks while the
   domain remains under the operator's control.  They do not protect
   against compromise of the domain itself - an attacker who can serve
   the domain's jwks.json can publish their own keys, and no key-level
   mechanism can detect that.  Domain-level security (DNS, TLS, hosting)
   is out of scope for VRP and is the operator's responsibility.

   Key compromise.  Freshness does not bound a key compromise; the JWKS
   cache bound (Section 4.3) is the revocation latency.  Immediate
   removal of a compromised key also invalidates the operator's own
   offers signed with it; this is intentional, since signatures from the
   operator and the attacker are indistinguishable under the same key.







Abbas                      Expires 19 May 2027                 [Page 17]

Internet-Draft           VRP Offer Verification            November 2026


   Enforcement honesty.  VRP cannot force a verifier to cache for a
   bounded time.  The cache bound is a requirement on conforming
   verifiers; there is no protocol backstop against a non-conforming
   verifier that caches a revoked key indefinitely.  The bound is a
   conformance requirement, not a guarantee the protocol can enforce.

   Booking-path integrity.  The constraints on direct_booking_url
   (Section 5.3) - host pinned to the signed canonical_domain, no third-
   party domains, shorteners, or redirectors, integrity solely from the
   enclosing JWS - exist to prevent a tampered or substituted offer from
   routing a guest's booking, and its payment, to an attacker.

   Amplification.  Section 4.2 asks verifiers to rate-limit or coalesce
   refresh-on-miss per domain, so that a stream of offers bearing
   unknown key identifiers cannot be used to drive traffic against a
   node's JWKS endpoint.

   What a valid signature proves.  A signature that verifies against the
   host domain's JWKS proves that a key the domain publishes signed
   exactly these terms: provenance and integrity of the offer.  Who
   holds the private key can be declared per node in
   operator.key_custody.  With self, the host holds it.  With platform,
   an operator holds and uses it on the host's behalf; the signature
   then proves that the domain's published key signed, not that the host
   itself held the key.  A verifier does not assume self-custody when
   key_custody is absent.

   Domain binding.  A valid signature proves which domain's key signed,
   not which domain the offer is about.  If the node at one domain signs
   an offer whose canonical_domain names another domain, the signature
   verifies against the signing node's JWKS; only the check that the
   offer names the domain it was fetched from (Section 6.2) stops a
   verifier from presenting it as the other domain's offer.

   The stay asked for.  A genuine offer for other dates or another guest
   count verifies like any other offer from the node.  Only the
   comparison with what the verifier asked for (Section 6.2) stops a
   verifier from quoting it for the wrong stay.

   Echoed request fields.  A node signs whatever it copies from the
   request.  If it copied free text, anyone could get a host-signed
   sentence of their own choosing by asking for it.  Section 5.2
   therefore limits what is copied to the stay and a language tag, and
   Section 6.2 forbids presenting either as the host's words.







Abbas                      Expires 19 May 2027                 [Page 18]

Internet-Draft           VRP Offer Verification            November 2026


   Offer lifetime.  A leaked key mints fresh offers whatever the
   lifetime, but an offer the node itself signed stays quotable after a
   price or availability change for at most its lifetime.  Section 5.2
   caps that at 900 seconds, and the check on generated_at (Section 6.1)
   keeps a start time in the future from stretching it.

   Concentration under platform custody.  An operator that holds the
   signing keys of many nodes is one point of compromise for all of
   them.  Rotation and revocation work per node: removing a compromised
   key from one node's JWKS de-trusts it for that node, within the cache
   bound.  A key that several nodes publish is de-trusted only where it
   is removed.

   Host-owned domains.  Only a domain registered for the host can be a
   node (Section 3.2).  A company that hands out names under its own
   domain, as the Public Suffix List's PRIVATE section records, cannot
   make those names VRP nodes, and neither can the operator of a brand
   or closed top-level domain.  ICANN's gTLD list marks brand top-level
   domains (Specification 13) but not every closed one; Section 3.2
   therefore names the closed top-level domains it stops beyond that
   list, and a closed top-level domain that is neither marked nor named
   is excluded by the rule's wording but not yet by a program.

   Fail-closed verification.  Whatever cannot be verified is unknown,
   never affirmed or negated (Section 6.3, Section 6.4), so a timeout, a
   malformed response or a failed signature check cannot be turned into
   a quote.

   Transport.  The discovery document is served over https only.
   jwks_url, verified_stay_offer_endpoint and direct_booking_url are
   node URLs, so https on the node's own domain (Section 3.3), and a
   verifier follows a redirect only to a node URL (Section 3.4).

   Tamper evidence.  A node MAY record signed-artifact hashes and key-
   rotation events in a public append-only transparency log (in the
   style of [RFC6962]), giving a tamper-evident - not immutable -
   history useful for after-the-fact disputes about whether an offer was
   signed by a then-valid key.

8.  Privacy Considerations

   The discovery document and the JWKS describe the site and its keys;
   they are public, machine-readable, site-wide metadata.  The discovery
   document MUST NOT contain guest personal data or secrets.  The JWKS
   carries public keys only (Section 4); this document states no
   separate rule for it.





Abbas                      Expires 19 May 2027                 [Page 19]

Internet-Draft           VRP Offer Verification            November 2026


   A verified stay offer echoes the requested dates and guest count.
   Offers are short-lived by design (valid_until), and verification is
   unauthenticated: fetching the discovery document, the JWKS, or an
   offer requires no verifier identity, so nodes learn no more about the
   requesting user than any web server learns from an HTTP request.

   The optional offer reference identifier in direct_booking_url
   (Section 5.3) lets a node correlate a booking-page visit with the
   signed offer it issued.  It is not required for verification.  This
   document sets no limit on how long such correlation data is kept;
   that is the host's decision.

   The checkIn, checkOut and guests query parameters that Section 5.3
   recommends put the quoted dates and guest count into
   direct_booking_url, so they reach browser history and server logs
   wherever the URL is followed.

9.  IANA Considerations

   This document requests no action from IANA.  The vacation-rental.json
   well-known URI suffix is already registered in the "Well-Known URIs"
   registry [RFC8615].  The entry, as the registry read on 2026-11-13:

   URI suffix:  vacation-rental.json

   Reference:
      https://vacationrentalprotocol.com/spec/well-known-uri-v0.1

   Status:  provisional

   Change controller:  Rouiada Abbas

   Date registered:  2026-08-19

   Section 3 of this document describes the same resource as the
   registered reference.  The registration request is recorded at
   https://github.com/protocol-registries/well-known-uris/issues/93.

   Existing deployments additionally serve the same resource at the
   transition alias suffix vacation-rental-protocol.json, which is not
   registered; clients SHOULD use vacation-rental.json (Section 3.7).

   The suffix names a descriptive discovery resource for one vertical (a
   vacation-rental node's site-wide configuration), in the naming style
   of other descriptive well-known resources; it is deliberately not a
   claim on the generic term "vacation-rental".

10.  References



Abbas                      Expires 19 May 2027                 [Page 20]

Internet-Draft           VRP Offer Verification            November 2026


10.1.  Normative References

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC3339]  Klyne, G. and C. Newman, "Date and Time on the Internet:
              Timestamps", RFC 3339, DOI 10.17487/RFC3339, July 2002,
              <https://www.rfc-editor.org/info/rfc3339>.

   [RFC5646]  Phillips, A., Ed. and M. Davis, Ed., "Tags for Identifying
              Languages", BCP 47, RFC 5646, September 2009,
              <https://www.rfc-editor.org/info/rfc5646>.

   [RFC7515]  Jones, M., Bradley, J., and N. Sakimura, "JSON Web
              Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May
              2015, <https://www.rfc-editor.org/info/rfc7515>.

   [RFC7517]  Jones, M., "JSON Web Key (JWK)", RFC 7517,
              DOI 10.17487/RFC7517, May 2015,
              <https://www.rfc-editor.org/info/rfc7517>.

   [RFC8037]  Liusvaara, I., "CFRG Elliptic Curve Diffie-Hellman (ECDH)
              and Signatures in JSON Object Signing and Encryption
              (JOSE)", RFC 8037, DOI 10.17487/RFC8037, January 2017,
              <https://www.rfc-editor.org/info/rfc8037>.

   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
              2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
              May 2017, <https://www.rfc-editor.org/info/rfc8174>.

   [RFC8259]  Bray, T., Ed., "The JavaScript Object Notation (JSON) Data
              Interchange Format", STD 90, RFC 8259,
              DOI 10.17487/RFC8259, December 2017,
              <https://www.rfc-editor.org/info/rfc8259>.

   [RFC8615]  Nottingham, M., "Well-Known Uniform Resource Identifiers
              (URIs)", RFC 8615, DOI 10.17487/RFC8615, May 2019,
              <https://www.rfc-editor.org/info/rfc8615>.

10.2.  Informative References

   [DID-WEB]  W3C Credentials Community Group, "did:web Method
              Specification", 2023,
              <https://w3c-ccg.github.io/did-method-web/>.





Abbas                      Expires 19 May 2027                 [Page 21]

Internet-Draft           VRP Offer Verification            November 2026


   [ICANN-GTLDS]
              ICANN, "gTLD Registry Agreements (machine-readable list)",
              2026,
              <https://www.icann.org/resources/registries/gtlds/v2/
              gtlds.json>.

   [PSL]      Mozilla Foundation, "Public Suffix List", 2026,
              <https://publicsuffix.org/list/>.

   [RFC6962]  Laurie, B., Langley, A., and E. Kasper, "Certificate
              Transparency", RFC 6962, DOI 10.17487/RFC6962, June 2013,
              <https://www.rfc-editor.org/info/rfc6962>.

   [RFC7942]  Sheffer, Y. and A. Farrel, "Improving Awareness of Running
              Code: The Implementation Status Section", BCP 205,
              RFC 7942, DOI 10.17487/RFC7942, July 2016,
              <https://www.rfc-editor.org/info/rfc7942>.

   [RFC9111]  Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke,
              Ed., "HTTP Caching", STD 98, RFC 9111,
              DOI 10.17487/RFC9111, June 2022,
              <https://www.rfc-editor.org/info/rfc9111>.

   [VRP-SPEC] Abbas, R., "Vacation Rental Protocol - Specification v0.1
              (public draft)", 2026,
              <https://vacationrentalprotocol.com>.

Appendix A.  Example Discovery Document























Abbas                      Expires 19 May 2027                 [Page 22]

Internet-Draft           VRP Offer Verification            November 2026


   {
     "protocol": "vacation-rental-protocol",
     "protocol_version": "0.1",
     "canonical_domain": "example-host.invalid",
     "node_id": "example-host.invalid",
     "jwks_url": "https://example-host.invalid/.well-known/jwks.json",
     "verified_stay_offer_endpoint":
       "https://example-host.invalid/api/verified-stay-offer",
     "capabilities": {
       "signed_verified_stay_offer": true,
       "live_availability": true,
       "exact_total_price": true,
       "direct_booking_url": true
     },
     "operator": {
       "name": "Example Host Platform",
       "role": "infrastructure_provider",
       "key_custody": "platform"
     }
   }

Appendix B.  Example JWKS

   {
     "keys": [
       {
         "kty": "OKP",
         "crv": "Ed25519",
         "kid": "example-host.invalid-2026-01-01-01",
         "use": "sig",
         "alg": "EdDSA",
         "key_ops": ["verify"],
         "x": "11qYAYLef_SPCb5r0x4n1uDZuQYgD4GZB8F6kS1v9KQ"
       }
     ]
   }

   Nodes may additionally publish the same verification keys via did:web
   [DID-WEB]; the JWKS remains the revocation authority for offer
   verification.

Appendix C.  Implementation Status

   This section is to be removed before publishing as an RFC.

   This section records the status of known implementations of the
   protocol defined by this specification, per [RFC7942].




Abbas                      Expires 19 May 2027                 [Page 23]

Internet-Draft           VRP Offer Verification            November 2026


   At the time of writing (November 2026), the protocol repository
   [VRP-SPEC] lists a reference implementation (a verifier, and a
   production node that serves the discovery document at the well-known
   URI, the Ed25519 JWKS, and signed verified stay offers with direct
   booking URLs); a signing node developed and operated by a party with
   no affiliation to the reference implementer, whose operator has been
   one of the maintainers of the protocol repository since October 2026;
   and a verifier developed by a party unrelated to the reference
   implementer, which checks the offer signature against the published
   key and the offer's expiry time.  The repository also keeps a draft
   implementation report, prepared for the decision on a later version
   of the protocol and measured against requirements of VRP v0.1.  For
   the requirements assessed, the report records implementation results
   with dated measurements or source references, and identifies gaps in
   independent implementation.  Machine-readable JSON Schemas for the
   discovery document, JWKS, and signed offer, together with executable
   conformance vectors (including negative cases: tampered signature,
   expired window, malformed attestations), are published in the same
   repository.  Specification text is dedicated to the public domain
   (CC0 1.0); reference code and conformance vectors are Apache-2.0.

Acknowledgements

   Thanks to the developers of the independent signing node and of the
   independent verifier listed in the protocol repository.

Author's Address

   Rouiada Abbas
   Vacation Rental Protocol
   Email: hello@vacationrentalprotocol.com
   URI:   https://vacationrentalprotocol.com



















Abbas                      Expires 19 May 2027                 [Page 24]
