| Internet-Draft | VRP Offer Verification | November 2026 |
| Abbas | Expires 19 May 2027 | [Page] |
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.¶
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.¶
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.¶
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).¶
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.¶
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.¶
canonical_domain in VRP documents.¶
https URL on the host domain or
www. followed by it (Section 3.3).¶
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.¶
protocol:vacation-rental-protocol.¶
protocol_version:0.1 for this version.¶
canonical_domain:jwks_url:verified_stay_offer_endpoint: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:¶
xn--) form, and has no trailing dot.¶
* applies. The list's PRIVATE section
does not count: it lists domains under which a company hands
out names to its customers.¶
"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).¶
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.¶
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).¶
A node SHOULD also publish:¶
node_id:capabilities:signed_verified_stay_offer,
live_availability, exact_total_price,
direct_booking_url).¶
endpoints:operator: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.¶
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.¶
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.¶
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}/:¶
<link rel="protocol" href="https://vacationrentalprotocol.com/">.¶
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.¶
Link: <https://vacationrentalprotocol.com/>;
rel="https://vacationrentalprotocol.com/rel/protocol".¶
"additionalType":
"https://vacationrentalprotocol.com/terms#VRPVacationRental".¶
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.¶
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.¶
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.¶
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.¶
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.¶
valid_until, then remove it.¶
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:¶
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.¶
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.¶
The verified stay offer endpoint accepts at least:¶
check_in:YYYY-MM-DD.¶
check_out:YYYY-MM-DD.¶
guests:The endpoint returns a signed verified stay offer envelope; the signed payload contains the quotable facts.¶
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.¶
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: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.¶
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.¶
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.¶
checkIn (YYYY-MM-DD, matching
request.check_in), checkOut
(YYYY-MM-DD, matching request.check_out), and
guests (integer, matching request.guests).¶
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.¶
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:¶
direct_booking_url
subject to the safe-to-quote rules
(Section 6.2).¶
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.¶
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.¶
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.¶
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:¶
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.¶
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.¶
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.¶
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).¶
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.¶
A verifier MUST NOT quote an offer as an official host-domain verified offer unless all of the following are true:¶
canonical_domain is that domain.¶
protocol: "vacation-rental-protocol".¶
protocol_version: "0.1".¶
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.¶
agent_permission.may_quote_as_official_direct_offer
is true.¶
Verifiers MUST NOT:¶
availability.available is true and agent permission
allows quoting.¶
price.exact is true in
the signed offer.¶
request as something the
host stated (Section 5.2).¶
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.¶
Verifiers and clients interacting with VRP nodes MUST distinguish three states for any required endpoint or field:¶
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.¶
VRP data falls into exactly three classes, and a surface MUST NOT present a lower class as a higher one:¶
exact and no_add_on_fees),
availability, valid_until,
source_authority, and
rules.refund_schedule. Tampering with any of them
invalidates the same signature.¶
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.¶
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.¶
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.¶
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.¶
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:¶
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".¶
{
"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"
}
}
¶
{
"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.¶
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.¶
Thanks to the developers of the independent signing node and of the independent verifier listed in the protocol repository.¶