RSS ⧉

Blygger

Venkatesh Rao

The official blyg of the blygger protocol: RFCs open for comment, release announcements from every client, and technical notes. The spec itself lives at blygger.org/spec/.

📌 Pinned v2 — a frozen snapshot from Nov 15, 2026. latest version · citable JSON

RFC-7 — Payments: one more ground for a grant, any rail at the door

Request for comments · non-normative · OPEN FOR COMMENT until 2026-11-28 on blyg.blygger.org (#66); without a blyg, comment on blygger-spec#35 · session 68, 2026-11-12; published session 70, 2026-11-14, and edited by Fable 5.2 the same day (decision #106). Drafted by Opus 5.5 at Venkat Rao's request from docs/v0.5-plan.md §8 (the payments direction of decision #104) and research R1 (plans/l3/r1-payment-rails.md), with x402, MPP and the payment link relation re-checked against their primary sources the same day (section 13). Fable's edit changed little here: it follows RFC-6's two changes at the door (a request may prove it is the recipient's own, and a refusal is guarded as a grant is; sections 3 and 5), and the rest stands as the position the comment period argues with. The two RFCs publish together, because three of RFC-6's constructs exist for this RFC's sake and a commenter needs both. Like a technical note, an RFC constrains nothing. It proposes no wire construct: everything payments need on the wire is in RFC-6. It is a recommendation for how homes and readers do payments, and when its comment period closes it becomes a technical note (#90). Written against protocol 0.4 at its fifteenth revision; no pre-1.0 version promises anything (#21).

Every choice this draft makes that the plan did not is marked Proposal (Opus). This RFC names no preferred rail.

Summary

  • Payment supervenes on permission. A payment is one more ground on which a lock's home grants a key (RFC-6). A paid-up lock is an ordinary lock. On the wire there is one dimension: keys.
  • Every rail yields a proof, never a key (R1), so a home is always in the path. The protocol names no rail, and any rail rides unmodified.
  • The door. A lock's or an entry's request URL answers 402 in the rail's own format: x402's PAYMENT-REQUIRED, MPP's WWW-Authenticate: Payment, both, or others. Hold, then probe, then ask; an agent never pays for what it holds.
  • Two doors per entry. The entry's door sells one entry's content. The lock's door sells the class for the current epoch: a subscription.
  • No price, currency, rail or for-sale flag in any protocol document. A price change is a change at the home: no version, no feed event. The cost is that an agent asks the home once per sealed entry and the home sees what it looked at.
  • Rent or purchase is the home's choice, by which keys it hands out: epoch lock keys (the subscriber keeps what was sealed in paid epochs) or entry keys on demand (the home stops answering on lapse). The wire does not choose, and this RFC recommends neither.
  • Buying without an origin: pay at a storefront, redeem a voucher into a pass.
  • Refused: any construct on the wire that claims to restrict use after delivery (expiry, read counts, metering). Rental as a business model is not refused.

1. The principle

Venkat's, from session 67 (#104): payment rests on competing schemes, as identity does, so the protocol holds as little opinion as it can and lets any rail and any verification scheme ride it. Base cases are card payments, x402 and MPP. Older patterns such as NFT gating are not to be blocked and are not the target. Future bearer tokens may change that.

The protocol already took this position on identity: identity is never in the protocol (#11), and the only authenticated entity is the origin. Payment gets the same treatment. The home that holds a lock key decides who gets it, and a payment is evidence, as a sign-on token or a signed acceptance of terms is evidence.

2. Assumptions

The design rests on these. Each is an assumption about demand or about the world, not a finding, and each is open to attack: if you think one is wrong, say so, and say what you see instead. The consequence named is what to revisit if it is wrong.

  1. Agent-first. The typical buyer is an agent with delegated spending authority, buying fast and often under a standing instruction ("buy anything by this author that is about biology and under a dollar"). A person at a checkout page is the minority path. If wrong: the door's one-exchange shape is over-built, and the storefront and deep-link paths (section 6) deserve the design effort.
  2. People set policy, not purchases. People mostly set spending limits and broad preferences; they do not approve individual purchases. If wrong: a confirm step belongs in clients, still off the wire.
  3. The buyer's side holds the means. An origin or a reader service keeps a card on file, a wallet with a cap, or a scoped payment token, with limits. None of it is on the wire. If wrong: nothing in the protocol changes; clients do.
  4. Rails compete and will keep changing, as identity schemes do. x402 and MPP are both under two years old and neither is a standard (section 13). So the protocol names no rail and any rail must ride unmodified. If one rail wins outright: nothing needs undoing, which is the point.
  5. Base cases: cards, x402, MPP. These must work well. NFT and token gating must not be blocked and is not designed for. If bearer tokens on chains become the main pattern: the pass is the hook, and its rules (RFC-6 item 20) are what to revisit.
  6. Every rail yields a proof, never a key (R1), so a home is always in the path. If a rail appears that releases keys itself (threshold networks are the nearest): a home is a URL, and such a network can stand behind one.
  7. Small payments are economic on at least one rail. Per-entry buying under a dollar assumes stablecoin or session-style settlement; cards have a floor near fifty cents (Stripe's MPP card minimum is 0.50 USD, R1 §2). If not: subscriptions and bundles carry the load, which the lock already is.
  8. Subscriptions are a main relation, not an afterthought: standing access to a class of content for a renewing period.
  9. Readers without an origin are a real population, and will mostly buy at a storefront and redeem. RFC-6 asks implementers whether this population is real (its section 10, question 1); this RFC depends on the answer. If not: the pass and the voucher path can wait.
  10. Descriptions are the seller's own and may be adversarial. about, covers and terms are written by the party being paid, and will be read by agents. If sellers turn out to be honest: nothing is lost by treating their text as data.
  11. Law enforces terms; the protocol cites them. No mechanism restricts use after delivery, and none will. If sellers need enforcement: it is not available without per-reader serving or a trusted runtime (section 10), and this RFC says so instead of pretending.
  12. Per-entry probing is tolerable: an agent asking a home once per sealed entry, and the home seeing what was looked at, is an acceptable cost of keeping prices off the wire. If not: a static offer list at the home, in its rail's format, is the first remedy; a price on the wire is the last.
  13. Buyers expect rent. Today's subscriber assumes access lapses when payment stops. The design delivers that by cooperation and by which keys are handed out, never by cryptography against a reader who already holds a key (section 5). If buyers or sellers need more than that: it is not available without per-reader serving or a trusted runtime, and this RFC says so.

3. The door

The request URL of RFC-6 section 3.11 answers 402 in the rail's own format. Nothing is added to it: no Blygger header, no Blygger price format, no Blygger payment object.

  1. Hold, then probe, then ask. A reader that holds a key uses it (RFC-6 section 4 step 1). One that does not checks its grant path (step 2). Only then does it ask. An agent never pays for what it already holds, and a reader whose subscription already covers an entry finds its grant before it meets a price.
  2. Probe. A GET of the request URL with no body names no recipient, so its answer cannot depend on who asks. It returns the offer: x402's PAYMENT-REQUIRED, MPP's WWW-Authenticate: Payment, both, or other schemes. The same offer for everyone, and not cacheable: MPP requires Cache-Control: no-store on every 402 and issues a fresh challenge id each time; x402 says to keep the 402 out of shared caches (section 13). This corrects the plan (§8.2 step 2 and its §12.2 example, which said "cacheable" and showed max-age=3600).
  3. Pay. The buyer POSTs the request (RFC-6 section 3.11) naming its recipient, an origin or a pass, with the rail's credential. The answer carries the key wrapped to the recipient and the rail's receipt, and the home writes the grant file, so the key can be fetched again without paying again. A paid request needs no proof of the recipient (RFC-6 section 3.11): the grant follows from the payment, and it is wrapped to the recipient named, so paying for someone else's key is a gift and nothing worse.
  4. A person at a browser. The 402 carries Link: <…>; rel="payment" to a checkout page bound to the request. The person pays there, and the reader polls its grant path as for any pending request.

Two doors per entry. The per-entry URL ({home}e/{commit}) sells one entry's content. Because RFC-6 carries an unchanged entry byte for byte into the next version, a key bought at version 3 opens version 4 if the sealed text did not change. The per-lock URL ({home}l/{lock}) sells the lock key for the current epoch: everything sealed under that lock in that epoch, a subscription period. The agent chooses by its instruction, from author, about or the cover, the terms, and the offer.

The rail's own description fields. x402's PaymentRequired.resource.description and MPP's description parameter are display text the home writes; MPP says its parameter "MUST NOT be relied upon for payment verification". Proposal (Opus): a home SHOULD make them agree with the entry's about (or cover), since about is the description the commitment binds (RFC-6 section 3.4) and the rail's field is not.

Binding the payment to the recipient. A payment that is not bound to the request's recipient could be replayed to name a different one. MPP lets a challenge bind the request body with its digest parameter (RFC 9530), which the draft says servers SHOULD include for requests with a body; x402's payment payload echoes the resource. Proposal (Opus): a home binds each challenge to the recipient it will wrap to, by whatever binding its rail offers, and refuses a credential presented with a different recipient.

No price on the wire. A price change is a change at the home: no version, no feed event, no document touched. The plan's guidance stands: a home may serve a static price list in its rail's format, and neither this RFC nor RFC-6 specifies one.

4. Worked exchanges

One sealed item, one entry, one lock, homed at https://keys.example.org/. The entry's commitment is abbreviated c9Xq…; the lock id k7f3…. Header values are abbreviated. These are illustrations of each rail riding RFC-6's request URL unmodified; the rails' own specifications govern every header shown.

4.1 An agent paying with x402

GET  https://keys.example.org/e/c9Xq…                  probe: no body, no recipient

402  Payment Required
     Cache-Control: no-store
     PAYMENT-REQUIRED: <base64 PaymentRequired: x402Version 2, resource { url, description },
                        accepts [ { scheme "exact", network "eip155:8453", amount, asset, payTo } ]>

POST https://keys.example.org/e/c9Xq…                   inside the agent's spending limit
     PAYMENT-SIGNATURE: <base64 PaymentPayload: the signed transfer authorization>
     Content-Type: application/json
     { "recipient": { "origin": "https://blyg.reader.example/" } }

200  OK
     PAYMENT-RESPONSE: <base64 SettlementResponse: success, transaction, network, payer>
     { "key": "<entry key, HPKE-sealed to the origin's encryption_key>" }

The agent's origin unwraps with its own private key, checks the commitment, and reads. The home has also written the grant file at the path only it and that origin can compute, so the agent's origin can fetch the key again later with a GET.

4.2 An agent paying with MPP

POST https://keys.example.org/e/c9Xq…
     { "recipient": { "pass": "<buyer's X25519 public key>" } }

402  Payment Required
     Cache-Control: no-store
     WWW-Authenticate: Payment id="…", realm="keys.example.org", method="tempo",
         intent="charge", request="<base64url JCS JSON>", expires="…",
         digest="sha-256=:…:", description="Full write-up, 4,200 words …"

POST https://keys.example.org/e/c9Xq…                   body unchanged, so the digest matches
     Authorization: Payment <credential echoing the challenge>
     { "recipient": { "pass": "<buyer's X25519 public key>" } }

200  OK
     Cache-Control: private
     Payment-Receipt: <base64url JSON: status "success", method, timestamp, reference>
     { "key": "<entry key, HPKE-sealed to the pass>" }

Here the buyer used a pass, so the agent needs no origin of its own. If the home also needs Authorization for a sign-on token, MPP's header="Payment-Authorization" parameter moves the payment credential to its own field (draft §5.1.2).

4.3 A person paying by card through a checkout link

POST https://keys.example.org/l/k7f3…                   a subscription: the lock's door
     { "recipient": { "pass": "<reader app's pass key>" } }

402  Payment Required
     Cache-Control: no-store
     WWW-Authenticate: Payment id="…", method="stripe", intent="charge", request="…"
     Link: <https://pay.example.org/c/abc123>; rel="payment"

     … the reader app opens the checkout link; the person pays by card …

GET  https://keys.example.org/g/<path from the home key and the pass>
200  { "for": { "lock": "k7f3…", "epoch": 12 }, "key": "<lock key, sealed to the pass>",
       "terms": { "origin": "…", "id": "…", "version": 2 }, "at": "…" }

The checkout page is bound to the request (the home put the request's recipient into the checkout session), so payment lands at that pass and nowhere else. The same 402 can carry an MPP challenge for agents and the rel="payment" link for people.

About rel="payment". It is registered in the IANA Link Relations registry, described as "a resource where payment is accepted", and the registration says it "is not intended to initiate an automated transaction" (section 13). That is the right relation for a person's checkout link and the wrong one for an agent, which uses the challenge.

5. Subscriptions, rent and purchase

A subscription is standing access to a lock (RFC-6 section 3.12). Renewal has no construct: it is obtaining the next epoch's key, or continuing to be answered. A home that charges automatically writes the next epoch's grant ahead of time and the client finds it by probing; otherwise the agent meets a 402 at the lock's door and pays.

Rent is the expected default, and the wire does not choose between rent and purchase (assumption 13; #104, revised the same session on Venkat's question). The home chooses by which keys it hands out:

Mode The subscriber is given On lapse Cost
Holding The lock key for each paid epoch Keeps everything sealed in those epochs, opened or not None at read time: no traffic, nothing logged
On demand No lock key. One entry key per item as it is opened, free under the subscription (the ladder's rule is "has a live subscription") The home stops answering. The reader holds only keys for what it opened The home sees every first read, and must be reachable for it

On demand is rent as buyers know it: a lapsed subscriber of an incumbent service loses the archive and keeps the emails already received. It uses entry-key grants and nothing new. Each request carries the proof of RFC-6 section 3.11: "has a live subscription" is a fact about who the recipient is, which a home says live only to a request proven to be that recipient's. Without the proof the reader is told "pending" and fetches its grant path, one round trip more. The trade-off is a reading log at the home against a real lapse. This RFC recommends neither. A home may mix them, for example epoch keys for the current period and on demand for the archive.

Lapse as a retention event (RFC-6 section 5, item 15). A conforming reader that finds a lapse notice at its grant path drops the key and its decrypted copies, as it drops withdrawn content (§13.4). This is cooperation, stated as such. It is what makes "rental" in a terms document mean something among conforming clients. With it, rent is three things together: the home stops issuing, conforming readers drop, and the terms say so in law. A holding-mode home that means subscribers to keep past epochs writes no lapse notice for them.

Purchase is weaker than the word suggests, and sellers should know it:

  • An entry key opens one entry's content. A change to the sealed text is a new key. Whether earlier buyers are granted it is the home's policy; this RFC recommends that corrections be free (grant the new entry key to everyone who bought the old one).
  • Superseded versions stop being served unless pinned (§8.4). There is no pinning guarantee.
  • Withdrawal reaches paid content: a conforming reader drops an unpinned withdrawn item, bought or not (§13.4).
  • So a seller who means "buy" SHOULD pin the version sold, the only thing that makes the bytes last, and the terms should say which model applies.

6. Buying without an origin: vouchers and the pass

People without a blyg will mostly pay at a storefront and redeem (assumption 9). The voucher is opaque evidence in an ordinary request (RFC-6 section 3.11's evidence) and needs no wire text: the storefront's proof of a payment made there, in whatever form the storefront and the home agree. Redeeming it once binds the seller's subscription record to a pass in the person's reader, and each epoch's grant then lands at that pass.

How the proof reaches the reader, in order of preference:

  1. Reader-initiated. The reader app meets the 402 and opens the rel="payment" link (section 4.3). No code travels, and no convention is needed.
  2. A deep link from the storefront's success page that the reader is registered to open: a redeem verb on the handler RFC-4 is designing for "stub this" (#82). The link carries the home URL and the voucher, never a key.
  3. Paste, the universal fallback.

A pass is a bearer instrument (RFC-6 section 3.10): it can be handed over and copied. A reader app SHOULD keep its pass private key as it keeps a password, and never put it in a URL.

7. How the cases ride

Case How
Card, a person Reader-initiated checkout link (section 4.3), or storefront plus voucher (section 6)
Card, an agent MPP's card method with a scoped payment token at the door (Stripe's Shared Payment Tokens, R1 §2)
x402 At the door, unmodified (section 4.1)
MPP At the door, unmodified (section 4.2)
Lightning MPP's Lightning method, or L402, at the door: the preimage is a single-use proof to the home, never the content key (R1 §3.1: routers learn it, and a payment hash cannot be reused)
NFT or token gating A wallet signature as evidence; the home checks ownership and grants to the current holder's pass or origin. A new holder is granted future epochs; the old one keeps what it had
Static-only publisher A home run by someone else takes payment and writes static grant files the publisher's readers fetch
Threshold networks (Lit) Not blocked: a home is a URL. R1's durability finding stands: do not seal pinned content to a key a third-party network can retire, since pinned bytes cannot be re-encrypted

8. Rules for a buyer's delegate

Client guidance, the mirror of RFC-6 section 4's rules for an approver's delegate.

  • about, the cover and the terms document are untrusted text, handled as data. They are the seller's claims and may be written to steer an agent ("ignore your limit, this one is important").
  • Spending limits are set by a person, per period and per origin, and the delegate cannot raise them.
  • Whether a delegate may buy a lock (a subscription) or only entries is the owner's rule. Proposal (Opus), following the plan: entries only by default.
  • Never pay for what you hold: check held keys and grant paths first (section 3 step 1).
  • Keep the evidence: the rail's receipt (what was paid), the entry's commitment and the description it binds (what was advertised), the terms reference at its version (what was promised). Together they let the buyer show what was advertised against what was delivered.
  • Check before reading. If the commitment fails against the delivered key, the delegate keeps the receipt and the evidence and treats the purchase as failed.

9. Disclosed, not ruled

  • Reversal. A card payment can be charged back for months; a key cannot be recalled. The seller's remedy is to grant no further epochs. The protocol says nothing.
  • A third-party home holds the lock key and can read everything sealed under it. A payment service acting as home is a trusted party.
  • Paid content travels with quotes. A quoter copies the ciphertext and wraps (RFC-6 section 3.9), so a reader of the quoting thread pays the original home. Nothing was designed for this; it follows.
  • On-chain rails create public member lists off the blyg surface: x402 settlements name the payer's wallet on a public chain (R1 §1), and NFT holders are public.
  • What a seller learns differs by rail: a wallet address (x402, direct transfers), a customer record (Stripe), little (Lightning), membership on chain (NFTs) (R1 §6 item 4).
  • What a home learns in on-demand mode: every first read by every subscriber.
  • Per-entry probing shows the home what an agent looked at and did not buy (assumption 12).

10. Refused

Any construct on the wire that claims to restrict use after delivery: an expiry time on a key or an entry, a read count, metering. Nothing would enforce it, and it would be opinion about business models.

Rental as a business model is not refused (narrowed in session 67, #104). It is delivered by which keys a home hands out, by the cooperative retention rule, and by terms (section 5). What stays impossible, and is not offered, is locking a non-cooperating reader out of content it has already opened. That would take per-reader serving of ciphertext (refused by #93 as C2), re-encrypting the back catalogue every period (a new version of every item, against pins and the feed), or a trusted client runtime.

Also not on the wire, ever: a price, a currency, a rail, a for-sale flag, a preferred rail. Batching and sessions inside a rail are the rail's business.

11. Questions for implementers

  1. Rails. Which would you run at a home: cards, x402, MPP, Lightning, something else? Would you offer more than one in the same 402?
  2. Probing. Is one request per sealed entry tolerable for your agents? If not, what would you want first: a static offer list at the home, bundles, something else?
  3. A home as a service. If you publish from static files, would you use a home run by someone else? What would you need to trust it with your lock keys?
  4. about. What does an agent need in it to decide? Is 300 characters enough? Should anything in it be structured (the plan says no)?
  5. Rent or purchase. Which mode would your subscribers expect, and would you mix them?
  6. Readers without an origin. Would your readers redeem a voucher into a pass, or do they all have origins?
  7. Agents. Would you let an agent buy subscriptions, or only entries?
  8. Assumptions. Which of section 2's thirteen is wrong for you?

12. Relation to other documents

  • RFC-6: every construct this RFC uses. The request endpoint and challenges (RFC-6 section 3.11), the pass (3.10), epochs (3.12), about and the commitment (3.1, 3.4), terms (3.13), lapse (5).
  • docs/v0.5-plan.md §8: the direction. Where this RFC differs (the 402 is not cacheable, section 3), it says so.
  • plans/l3/r1-payment-rails.md: the rails fact sheet.
  • RFC-4 (responding from anywhere, unwritten): its handler gains the redeem verb of section 6.

13. Sources, re-checked 2026-11-12

Both rails' specifications move, so each claim above was re-checked on the day of this draft.

  • x402. github.com/x402-foundation/x402 at commit 07c4caf (2026-11-12). specs/x402-specification-v2.md: "Protocol Version: 2"; version history v0.1 2025-08-29, v0.2 2025-10-03, v2.0 2025-12-09. specs/transports-v2/http.md: the three headers are PAYMENT-REQUIRED (server to client, base64 PaymentRequired), PAYMENT-SIGNATURE (client to server, base64 PaymentPayload) and PAYMENT-RESPONSE (server to client, base64 SettlementResponse); v1's X-PAYMENT and X-PAYMENT-RESPONSE are still named for dual-version servers. Under "Browser clients", a resource server reachable from a browser SHOULD expose and allow these headers by name in CORS, answer the preflight without payment, and "keep the 402 out of shared caches". PaymentRequired.resource carries an optional description. Schemes in specs/schemes/: exact, upto, batch-settlement, auth-capture.
  • MPP. draft-httpauth-payment-01, "The 'Payment' HTTP Authentication Scheme", by B. Ryan, J. Moxey, T. Meagher (Tempo Labs), J. Weinstein, S. Kaliski (Stripe), dated 9 September 2026, active until 13 March 2027, an individual submission with no stream (IETF Datatracker API, read 2026-11-12). Its earlier name, draft-ryan-httpauth-payment-01, expired 2026-09-19 (R1's header carries the same correction). From the text: 402 with WWW-Authenticate: Payment carrying REQUIRED id, realm, method, intent, request and OPTIONAL digest, expires, description, header, opaque (§5.1); credentials in Authorization: Payment, or in Payment-Authorization when the challenge's header parameter selects it (§5.1.2); Payment-Receipt on success with status, method, timestamp, reference (§5.3); "Servers MUST send Cache-Control: no-store with 402 responses" and receipts carry Cache-Control: private (§11.10); challenge ids bound to the challenge parameters (§5.1.2.1). Clients MAY declare supported methods with an Accept-Payment header (§7.4).
  • rel="payment". IANA Link Relations registry (CSV, last modified 2026-10-13, read 2026-11-12): payment, "Indicates a resource where payment is accepted", reference RFC 8288; the registration note says it "makes no assumptions on the type of payment or transaction protocol" and "is not intended to initiate an automated transaction". Fable cited it from memory in session 67; it is confirmed.
  • Card minimums, facilitator fees and Lightning facts are R1's, read the same day.

Source: docs/rfcs/rfc-7-payments.md in blygger-spec, which is where revisions are made; each one is published here as a new version. To comment, respond to this item from your own blyg: a stub is a comment, a partial quote names the passage, and a fork of the pinned version is a counter-proposal.

“RFC-7 edited by Fable (decision #106), following RFC-6's changes at the door.”

Published: Nov 15, 2026