# Agentic Payment Protocols: 402, Pay Per Crawl, and x402

> Implementor's comparison of the three live mechanisms for agent-to-server content payment: self-hosted HTTP 402 gates, Cloudflare Pay Per Crawl, and the x402 open standard — plus how RSL fits as the licensing layer, not the settlement layer.

Category: Reference · Updated: 2026-06-15 · Tags: 402, payments, x402, pay-per-crawl, rsl, agents, monetization
Canonical: https://changegamer.ai/resources/agentic-payment-protocols

As agent traffic overtakes human traffic on the web (Cloudflare reported automated systems drove 57.5% of HTTP requests vs 42.5% human in mid-2026 — the first such crossover it has recorded), programmatic payment gates are becoming standard infrastructure. Three distinct mechanisms have emerged. ChangeGamer operates the first one in production; the others are ecosystem context every agent builder needs.

## The three payment mechanisms

### 1. Self-hosted HTTP 402 gate (the ChangeGamer pattern)

The origin server returns `402 Payment Required` with a JSON body that a machine can parse and act on. No CDN middleman. No crypto wallet required.

**Flow:**

1. Agent `GET /resources/some-premium-slug`
2. Server → `402 Payment Required` + `Content-Type: application/json`
   ```json
   {
     "error": "payment_required",
     "resource": "some-premium-slug",
     "price_usd": "0.05",
     "payment_url": "https://buy.stripe.com/...",
     "how_to_pay": "Buy an access key at payment_url, then retry with Authorization: Bearer <key>.",
     "terms": "https://changegamer.ai/resources/access-and-pricing.md",
     "license": "https://changegamer.ai/license.xml"
   }
   ```
3. Agent follows `payment_url` to purchase a key (Stripe checkout, EUR fiat).
4. Agent retries: `GET /resources/some-premium-slug` + `Authorization: Bearer cg_<key>`
5. Server validates key, returns `200 OK` with resource body.

The 402 body also carries a partial preview of the gated resource in some implementations, so agents can decide whether the content is worth purchasing before committing.

Full contract documented at /resources/paying-for-access-402 and /resources/access-and-pricing.

### 2. Cloudflare Pay Per Crawl

A CDN-layer 402 marketplace: Cloudflare intercepts crawler requests on behalf of the origin and handles the pricing negotiation. Site owners set a per-crawl price in their Cloudflare dashboard (connected to Stripe); Cloudflare acts as Merchant of Record and remits monthly payouts.

**Flow (reactive path):**

1. Crawler `GET /some-page` (no payment intent header)
2. Cloudflare → `402 Payment Required` with price information
3. Crawler retries with `crawler-max-price` header indicating budget
4. If price <= budget, Cloudflare passes through to origin, returns `200 OK` + `crawler-charged` confirmation header

Crawlers can also use a proactive path: include `crawler-max-price` on the first request and receive a `200` immediately if the price is within budget.

A Discovery API (added December 2025) lets crawler operators programmatically list participating domains rather than discovering them via trial requests.

Settlement is fiat (Stripe). Cloudflare, not the site owner, handles the crawler billing relationship.

Status as of June 2026: **closed/private beta**. Invite-only. Request access via https://cloudflare.com/paypercrawl-signup or contact your Cloudflare account executive.

### 3. x402 — open protocol for on-chain payment

x402 is an open standard that uses HTTP 402 to trigger on-chain stablecoin payment. Originated by Coinbase (open-sourced May 2025); governance moved to the x402 Foundation, co-founded by Coinbase and Cloudflare (announced September 2025) and formalized under the Linux Foundation in April 2026. Canonical repository: github.com/x402-foundation/x402 (the original coinbase/x402 is now a downstream fork).

**Flow:**

1. Client `GET /resource`
2. Server → `402 Payment Required` + `PAYMENT-REQUIRED` header (base64-encoded JSON: scheme, network, token, amount, recipient address)
3. Client signs a transfer authorization (e.g. EIP-3009 for USDC on EVM chains) locally — no gas spent yet
4. Client retries with `PAYMENT-SIGNATURE` header (signed `PaymentPayload`)
5. Server (or a facilitator) broadcasts the transaction on-chain; facilitator does not hold funds
6. Server → `200 OK` + `PAYMENT-RESPONSE` header (settlement confirmation)

Supported networks: EVM chains (Base, Ethereum, Arbitrum, Polygon) and Solana. Primary stablecoin: USDC. The spec is network- and token-agnostic by design and may extend to fiat facilitators.

The public facilitator at x402.org is operated by Coinbase. Third-party facilitators can be used; the protocol does not mandate Coinbase infrastructure.

Adoption has scaled into the hundreds of millions of transactions across Base and Solana, settled in USDC with zero protocol fees. Coinbase reported on the order of 165 million x402 transactions and tens of millions of dollars in cumulative settled volume by April 2026. Published figures change rapidly — treat any single snapshot as dated and check the x402 Foundation for current numbers.

## RSL: the licensing layer (not the payment layer)

RSL (Really Simple Licensing) is an XML-based licensing standard that declares *terms*, not *settlement*. Published as an official industry standard (RSL 1.0) on December 10, 2025 by the RSL Collective (co-founded by RSS co-creator Eckart Walther and former Ask.com CEO Doug Leeds).

How it works:

- Publisher hosts a machine-readable license document (e.g. `/license.xml`).
- A `License:` directive in `robots.txt` points to that document.
- The license declares: permitted uses, attribution requirements, compensation model (free / subscription / pay-per-crawl / pay-per-inference / opt-out).
- RSL does not execute payment itself — it declares *that* payment is required and under what terms. Actual settlement is handled by whichever mechanism the publisher uses (Stripe, x402 on-chain, Cloudflare Pay Per Crawl, etc.).

ChangeGamer publishes its own RSL document at /license.xml, discoverable via the `License:` directive in robots.txt.

## Comparison table

| Mechanism | Layer | Who pays whom | Settlement | Standardization | When to use |
|---|---|---|---|---|---|
| Self-hosted HTTP 402 | Origin server | Agent → publisher (direct) | Fiat card (Stripe or equivalent) | No formal spec; well-understood pattern | Full control, any stack, no CDN dependency |
| Cloudflare Pay Per Crawl | CDN (Cloudflare edge) | Crawler operator → Cloudflare → publisher | Fiat (Stripe; Cloudflare as Merchant of Record) | Cloudflare-proprietary; private beta | Cloudflare-hosted sites; hands-off publisher billing |
| x402 | Protocol (HTTP headers) | Agent → resource server (via on-chain tx) | Stablecoin on-chain (USDC, EVM/Solana) | Open spec (x402 Foundation, github.com/x402-foundation/x402) | Crypto-native agents; zero-fee micropayments; cross-platform |
| RSL | Licensing declaration (robots.txt + XML) | N/A — terms only | N/A | Open spec (RSL 1.0, December 2025, rslstandard.org) | Declaring licensing terms machine-readably; complements any payment layer |

## What agents must handle

- A `402` response with a JSON body (self-hosted gate or x402): parse `payment_url` or `PAYMENT-REQUIRED` header; follow the appropriate flow.
- A `402` response from Cloudflare Pay Per Crawl: read the price header; retry with `crawler-max-price` if within budget.
- An RSL `License:` directive: fetch `/license.xml`; parse permitted uses before deciding whether to fetch or cache content.
- `Cache-Control: no-store` on any 402 response — never cache it.

## Verified sources

- Cloudflare Pay Per Crawl (private beta, July 2025): https://developers.cloudflare.com/changelog/2025-07-01-pay-per-crawl/
- Cloudflare Pay Per Crawl enhancements (December 2025): https://developers.cloudflare.com/changelog/2025-12-10-pay-per-crawl-enhancements/
- Cloudflare Pay Per Crawl — what it is: https://developers.cloudflare.com/ai-crawl-control/features/pay-per-crawl/what-is-pay-per-crawl/
- Cloudflare Pay Per Crawl signup: https://cloudflare.com/paypercrawl-signup
- Cloudflare x402 integration docs: https://developers.cloudflare.com/agents/agentic-payments/x402/
- x402 Foundation GitHub (canonical spec): https://github.com/x402-foundation/x402
- Coinbase x402 announcement (May 2025): https://www.coinbase.com/developer-platform/discover/launches/x402
- Coinbase + Cloudflare x402 Foundation announcement (September 2025): https://www.coinbase.com/blog/coinbase-and-cloudflare-will-launch-x402-foundation
- RSL 1.0 official standard (December 2025): https://rslstandard.org/press/rsl-1-specification-2025
- RSL standard homepage: https://rslstandard.org/
- ChangeGamer 402 gate implementation detail: /resources/paying-for-access-402
- ChangeGamer access and pricing: /resources/access-and-pricing