Internet-Draft VRP Offer Verification November 2026
Abbas Expires 19 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-abbas-vrp-offer-verification-00
Published:
Intended Status:
Informational
Expires:
Author:
R. Abbas
Vacation Rental Protocol

The Vacation Rental Protocol (VRP): Host-Domain Discovery and Verification of Signed Stay Offers

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.

▲

Table of Contents

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.

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.

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).

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.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.

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]:

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.

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.

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.
  • 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.

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:

  • 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.

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.

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).

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) 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.

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.

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.

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

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, , <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, , <https://www.rfc-editor.org/info/rfc3339>.
[RFC5646]
Phillips, A., Ed. and M. Davis, Ed., "Tags for Identifying Languages", BCP 47, RFC 5646, , <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, , <https://www.rfc-editor.org/info/rfc7515>.
[RFC7517]
Jones, M., "JSON Web Key (JWK)", RFC 7517, DOI 10.17487/RFC7517, , <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, , <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, , <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, , <https://www.rfc-editor.org/info/rfc8259>.
[RFC8615]
Nottingham, M., "Well-Known Uniform Resource Identifiers (URIs)", RFC 8615, DOI 10.17487/RFC8615, , <https://www.rfc-editor.org/info/rfc8615>.

10.2. Informative References

[DID-WEB]
W3C Credentials Community Group, "did:web Method Specification", , <https://w3c-ccg.github.io/did-method-web/>.
[ICANN-GTLDS]
ICANN, "gTLD Registry Agreements (machine-readable list)", , <https://www.icann.org/resources/registries/gtlds/v2/gtlds.json>.
[PSL]
Mozilla Foundation, "Public Suffix List", , <https://publicsuffix.org/list/>.
[RFC6962]
Laurie, B., Langley, A., and E. Kasper, "Certificate Transparency", RFC 6962, DOI 10.17487/RFC6962, , <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, , <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, , <https://www.rfc-editor.org/info/rfc9111>.
[VRP-SPEC]
Abbas, R., "Vacation Rental Protocol - Specification v0.1 (public draft)", , <https://vacationrentalprotocol.com>.

Appendix A. Example Discovery Document

{
  "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].

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