# What Is x402? The HTTP 402 Payment Protocol for AI Agents, Explained (2026)
> x402 in plain English: how the HTTP 402 status code lets AI agents pay per request, how Cloudflare pay per crawl works, and what site owners should do now.
- Source: https://www.taskade.com/blog/x402-protocol-explained
- Published: 2026-11-14
- Author: Stan Chang
For 28 years, one line in the HTTP specification did nothing. Status code 402, Payment Required, was defined in January 1997 with a single sentence: "This code is reserved for future use." The web grew up on advertising instead.
In 2025 the future arrived. AI agents started reading the web for people, and a page that an agent reads earns no ad view. A protocol called **x402** gave that old status code a job: a server can now reply to any request with a price, and software can pay it in the same exchange. This guide explains how x402 works, how Cloudflare pay per crawl relates to it, who gets paid, and what a site owner or builder can do about it today.
> **TL;DR:** x402 is an open protocol that lets AI agents pay for a web page, API call or tool inside a normal HTTP request, with status code 402. Coinbase announced it on May 6, 2025, and 40 organizations joined the [x402 Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-operational-launch-of-x402-foundation-to-standardize-internet-native-payments-for-ai-agents-and-applications) in July 2026. Real payment volume is still small.
**Quick answer: what is x402?** x402 is a payment protocol built on the HTTP status code 402 Payment Required. A server answers an unpaid request with 402 and a price. The client signs a payment and repeats the request. A service called a facilitator verifies and settles the payment, and the server returns the resource. No account, API key or checkout page is needed.
**In this guide:** [What x402 is](#what-is-x402) · [Why 402 sat unused](#why-did-http-402-sit-unused-for-28-years) · [Timeline](#x402-timeline-key-dates-from-1997-to-2026) · [The handshake](#how-does-the-x402-handshake-work) · [The actors](#who-are-the-actors-in-an-x402-payment) · [Payment schemes](#which-payment-schemes-does-x402-support) · [V1 vs V2](#x402-v1-vs-v2-what-changed) · [Pay per crawl](#what-is-cloudflare-pay-per-crawl) · [Monetization Gateway](#what-is-the-cloudflare-monetization-gateway) · [Wallets and identity](#how-do-ai-agents-hold-money-and-prove-who-they-are) · [x402 vs ACP, AP2, MCP](#x402-vs-acp-vs-ap2-vs-mcp-vs-l402-vs-api-keys) · [Usage numbers](#how-much-money-moves-over-x402-today) · [Who gets paid](#who-gets-paid-in-the-agent-internet) · [Site owners](#what-should-site-owners-do-about-ai-agents) · [What people build](#what-are-people-building-on-top-of-x402) · [Limitations](#what-are-the-limitations-and-open-questions) · [FAQ](#frequently-asked-questions-about-x402)
---
## ⚡ What Is x402?
**x402 is an open protocol for paying over HTTP.** A server that wants payment replies to a request with status code 402 and a machine-readable price. The client pays and retries. [Coinbase announced x402 on May 6, 2025](https://cointelegraph.com/news/coinbase-x402-payments-protocol-make-ai-agents-more-autonomous), and the project site calls it "an open, neutral standard for internet-native payments" ([x402.org](https://www.x402.org/)).
The idea matters because of who the customer is. A person will not approve a payment of one cent to read one page. An [AI agent](https://www.taskade.com/blog/what-are-ai-agents) can, because the payment is automatic and the agent works for someone with a budget. Cloudflare put the shift in one sentence when it announced its own x402 product: "The natural unit of payment for software is the request, the token, or the outcome, not the seat or the month" ([Cloudflare, July 1, 2026](https://blog.cloudflare.com/monetization-gateway/)).
| Quick fact | Value | Source |
|---|---|---|
| What it is | An open protocol for payments inside HTTP requests | [x402.org](https://www.x402.org/) |
| Status code it uses | 402 Payment Required | [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-402-payment-required) |
| Announced | May 6, 2025, by Coinbase Developer Platform | [Cointelegraph](https://cointelegraph.com/news/coinbase-x402-payments-protocol-make-ai-agents-more-autonomous) |
| Current version | V2, launched December 2025 | [x402.org](https://www.x402.org/writing/x402-v2-launch) |
| Governance | x402 Foundation at the Linux Foundation, 40 members at launch on July 14, 2026 | [Linux Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-operational-launch-of-x402-foundation-to-standardize-internet-native-payments-for-ai-agents-and-applications) |
| Usual currency | USDC stablecoin | [Coinbase docs](https://docs.cdp.coinbase.com/x402/core-concepts/how-it-works) |
| Protocol fee | None. Network fees still apply | [x402.org](https://www.x402.org/) |
| Lifetime transactions | About 199 million on November 12, 2026 | [agenteconomy.to](https://agenteconomy.to/x402) |
Three plain-English points clear up most confusion:
1. **x402 is a protocol, not a coin.** There is nothing called an x402 token to buy.
2. **x402 is not a Cloudflare product.** Cloudflare builds products on it, and Coinbase started it. A foundation now governs it.
3. **x402 is not the same as pay per crawl.** Both use status code 402. They work differently, and a [later section](#what-is-cloudflare-pay-per-crawl) shows how.
---
## 🕰️ Why Did HTTP 402 Sit Unused for 28 Years?
**HTTP 402 sat unused because the 1990s web had no cheap way to move one cent.** The authors of HTTP/1.1 reserved the code in [RFC 2068 in January 1997](https://www.rfc-editor.org/rfc/rfc2068#section-10.4.3). The current HTTP standard, [RFC 9110 from June 2022](https://www.rfc-editor.org/rfc/rfc9110.html#name-402-payment-required), repeats the same placeholder.
```
RFC 2068, January 1997 RFC 9110, June 2022
---------------------- -------------------
10.4.3 402 Payment Required 15.5.3. 402 Payment Required
This code is reserved for The 402 (Payment Required)
future use. status code is reserved for
future use.
401 Unauthorized "Who are you?" widely used
402 Payment Required "Pay first." reserved, 1997 to 2025
403 Forbidden "You may not." widely used
404 Not Found "No such thing." widely used
```
Companies did try to build digital cash for the early web. [DigiCash](https://en.wikipedia.org/wiki/DigiCash), founded by David Chaum in 1989, declared bankruptcy in 1998. [CyberCash](https://en.wikipedia.org/wiki/CyberCash), founded in August 1994, offered a micropayment system called CyberCoin. None of them became part of the browser. [MDN's reference page for 402](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/402) still describes the code as reserved for future use.
| Blocker in the 1990s | Why it stopped micropayments | What changed by 2025 |
|---|---|---|
| Card fees | A fixed fee per card payment is larger than a one-cent price | Stablecoin transfers can carry fractions of a cent |
| No wallet in the client | A browser had no standard way to hold or send money | Software wallets can sign a payment in code |
| Human friction | A person will not approve a tiny payment for each page | The buyer is software that follows a budget |
| No shared standard | Each payment company used its own format | One header format, governed by a foundation |
| Advertising worked | A free page with ads paid better than a toll | Agents read pages and view no ads |
The last row is the one that broke the old bargain. A search crawler read a page, sent a human visitor, and the site sold that visitor's attention. An agent reads the same page, gives its user the answer, and nobody visits. The content created value and the site earned nothing.
```mermaid
graph TD
subgraph OLD["The search bargain"]
A1["Crawler reads the page"] --> A2["Search engine lists it"]
A2 --> A3["A person clicks through"]
A3 --> A4["The site earns from attention
ads, email, affiliate links"]
end
subgraph NEW["The agent flow"]
B1["Agent reads the page"] --> B2["Agent extracts the answer"]
B2 --> B3["The user gets the answer
and never visits"]
B3 --> B4["The site earns nothing
unless the request has a price"]
end
style OLD fill:#0a1420,stroke:#1a2a45
style NEW fill:#1a140a,stroke:#3a2a1a
style A4 fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style B4 fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style A1 fill:#1e1e2e,color:#94a3b8,stroke:#475569
style A2 fill:#1e1e2e,color:#94a3b8,stroke:#475569
style A3 fill:#1e1e2e,color:#94a3b8,stroke:#475569
style B1 fill:#1e1e2e,color:#94a3b8,stroke:#475569
style B2 fill:#1e1e2e,color:#94a3b8,stroke:#475569
style B3 fill:#1e1e2e,color:#94a3b8,stroke:#475569
```
Cloudflare made the same argument on July 1, 2025, in a post titled [Content Independence Day](https://blog.cloudflare.com/content-independence-day-no-ai-crawl-without-compensation/), and shipped pay per crawl the same day. The introduction of that feature says it plainly: the goal was to "dust off a mostly forgotten piece of the web" ([Cloudflare, July 1, 2025](https://blog.cloudflare.com/introducing-pay-per-crawl/)).
---
## 📅 x402 Timeline: Key Dates From 1997 to 2026
**x402 went from a whitepaper to a 40-member foundation in 14 months, from May 2025 to July 2026.** The table lists each dated event with its source. Every date below comes from the linked primary page or, where marked, from press coverage.
| Date | Event | Source |
|---|---|---|
| January 1997 | RFC 2068 reserves status code 402 "for future use" | [RFC 2068](https://www.rfc-editor.org/rfc/rfc2068#section-10.4.3) |
| June 2022 | RFC 9110, the current HTTP standard, keeps 402 reserved | [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-402-payment-required) |
| September 3, 2024 | Jeremy Howard proposes the llms.txt file | [llmstxt.org](https://llmstxt.org/) |
| May 6, 2025 | Coinbase announces x402. Press coverage names AWS, Anthropic, Circle and NEAR as launch partners | [Cointelegraph](https://cointelegraph.com/news/coinbase-x402-payments-protocol-make-ai-agents-more-autonomous) |
| May 15, 2025 | Cloudflare proposes Web Bot Auth, signed requests for bots and agents | [Cloudflare](https://blog.cloudflare.com/web-bot-auth/) |
| July 1, 2025 | Cloudflare launches pay per crawl in private beta | [Cloudflare](https://blog.cloudflare.com/introducing-pay-per-crawl/) |
| September 16, 2025 | Google announces the Agent Payments Protocol, AP2 | [Google Cloud](https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol) |
| September 23, 2025 | Cloudflare and Coinbase announce plans for an x402 Foundation | [Cloudflare](https://blog.cloudflare.com/x402/) |
| September 26, 2025 | Cloudflare announces AI Index in private beta | [Cloudflare](https://blog.cloudflare.com/an-ai-index-for-all-our-customers/) |
| September 29, 2025 | Stripe and OpenAI release the Agentic Commerce Protocol | [Stripe](https://stripe.com/newsroom/news/stripe-openai-instant-checkout) |
| October 14, 2025 | Visa announces the Trusted Agent Protocol, built with Cloudflare | [Visa](https://usa.visa.com/about-visa/newsroom/press-releases.releaseId.21716.html) |
| December 2025 | x402 V2 launches with new headers and a plugin design (the launch post shows no publish date, so the month is from press coverage) | [x402.org](https://www.x402.org/writing/x402-v2-launch) |
| February 12, 2026 | Cloudflare launches Markdown for Agents | [Cloudflare](https://blog.cloudflare.com/markdown-for-agents/) |
| April 2, 2026 | The Linux Foundation announces the x402 Foundation | [Linux Foundation](https://www.prnewswire.com/news-releases/linux-foundation-is-launching-the-x402-foundation-and-welcoming-the-contribution-of-the-x402-protocol-302732803.html) |
| July 1, 2026 | Cloudflare announces the Monetization Gateway, with a waitlist | [Cloudflare](https://blog.cloudflare.com/monetization-gateway/) |
| July 14, 2026 | The x402 Foundation starts operations with 40 members | [Linux Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-operational-launch-of-x402-foundation-to-standardize-internet-native-payments-for-ai-agents-and-applications) |
| August 4, 2026 | Cloudflare announces Cloudflare Wallets for agents | [Cloudflare](https://blog.cloudflare.com/wallets/) |
| September 30, 2026 | Monetization Gateway and Pay Per Use enter beta | [Cloudflare](https://blog.cloudflare.com/monetization-gateway-beta) |
```mermaid
graph TD
E1["1997 to 2024
402 is reserved and unused"] --> E2["May 2025
Coinbase announces x402"]
E2 --> E3["July 2025
Cloudflare pay per crawl, private beta"]
E3 --> E4["September 2025
AP2, ACP and the x402 Foundation plan"]
E4 --> E5["December 2025
x402 V2"]
E5 --> E6["July 2026
Linux Foundation launch, 40 members"]
E6 --> E7["September 2026
Cloudflare Monetization Gateway beta"]
style E1 fill:#1e1e2e,color:#94a3b8,stroke:#475569
style E2 fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style E3 fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style E4 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style E5 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style E6 fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style E7 fill:#11111b,color:#cdd6f4,stroke:#00d4aa
```
The membership list is the detail that changed how the industry reads x402. The foundation's 17 premier members include Adyen, AWS, American Express, Circle, Cloudflare, Coinbase, Fiserv, Google, Mastercard, Shopify, Stripe and Visa. A protocol that began as a crypto project now counts the card networks and the largest payment processors among its premier members. Our [history of Shopify](https://www.taskade.com/blog/history-of-shopify) covers the commerce side of that story.
---
## 🤝 How Does the x402 Handshake Work?
**An x402 payment is two HTTP requests: one that fails with a price, and one that succeeds with proof of payment.** The x402 V2 documentation defines three headers for the exchange: `PAYMENT-REQUIRED`, `PAYMENT-SIGNATURE` and `PAYMENT-RESPONSE`. Each one carries a Base64-encoded JSON object ([x402 docs](https://docs.x402.org/core-concepts/http-402)).
```mermaid
sequenceDiagram
participant C as Client or agent
participant S as Resource server
participant F as Facilitator
participant N as Payment network
C->>S: GET /report with no payment
S-->>C: 402 + PAYMENT-REQUIRED
C->>C: Read the price and sign a payment
C->>S: GET /report + PAYMENT-SIGNATURE
S->>F: Verify this payment
F-->>S: Payment is valid
S->>S: Do the requested work
S->>F: Settle this payment
F->>N: Submit the transfer
N-->>F: Transfer confirmed
F-->>S: Settlement result
S-->>C: 200 OK + PAYMENT-RESPONSE
```
That sequence follows the nine steps in [Coinbase's x402 documentation](https://docs.cdp.coinbase.com/x402/core-concepts/how-it-works). Two details are easy to miss. First, in this default flow the server does the work between verification and settlement, so a failed job does not have to be charged. The V2 specification allows a scheme to settle before the work, so check the scheme before you rely on that order. Second, the client never talks to the facilitator. The server does.
Here is what the exchange looks like on the wire. The header values are shortened, and the decoded payload is a simplified illustration. The [x402 specification on GitHub](https://github.com/coinbase/x402) holds the exact schema.
```
REQUEST 1 (no payment)
-----------------------
GET /api/market-report HTTP/1.1
Host: data.example.com
User-Agent: research-agent/1.0
RESPONSE 1
----------
HTTP/1.1 402 Payment Required
PAYMENT-REQUIRED: eyJ4NDAyVmVyc2lvbiI6Miwi... (Base64 JSON)
decoded, simplified:
{
"x402Version": 2,
"accepts": [{
"scheme": "exact",
"network": "",
"asset": "",
"amount": "",
"payTo": ""
}]
}
REQUEST 2 (same request, now with proof)
-----------------------------------------
GET /api/market-report HTTP/1.1
Host: data.example.com
User-Agent: research-agent/1.0
PAYMENT-SIGNATURE: eyJzY2hlbWUiOiJleGFjdCIs... (Base64 JSON, signed)
RESPONSE 2
----------
HTTP/1.1 200 OK
PAYMENT-RESPONSE: eyJzdWNjZXNzIjp0cnVlLCJ0... (Base64 JSON receipt)
Content-Type: application/json
{ "report": "..." }
```
| Header | Direction | What it carries |
|---|---|---|
| `PAYMENT-REQUIRED` | Server to client, with the 402 | The price, the accepted asset and network, and the destination |
| `PAYMENT-SIGNATURE` | Client to server, on the retry | The signed payment payload |
| `PAYMENT-RESPONSE` | Server to client, with the result | The settlement response, which works as a receipt |
A single request moves through a small set of states. The diagram shows only the forward path. If verification fails, the server answers with 402 again and the client can try once more.
```mermaid
stateDiagram-v2
[*] --> Requested: client asks for a resource
Requested --> PriceQuoted: server replies 402 with a price
PriceQuoted --> Signed: client signs a payment
Signed --> Verified: facilitator checks the payment
Verified --> Served: server does the work
Served --> Settled: facilitator settles the payment
Settled --> [*]: client receives the resource and a receipt
```
The whole exchange happens without a signup form. x402.org contrasts it with the usual path to a paid API: create an account, add a payment method, buy credits, manage an API key, then make the call. With x402 the payment is the credential. That is why Cloudflare describes the result as "No signup, no API key, no prior relationship required" ([Cloudflare](https://blog.cloudflare.com/monetization-gateway/)). For background on how requests, gateways and caches fit together, see [system design explained](https://www.taskade.com/blog/system-design-explained).
---
## 🧱 Who Are the Actors in an x402 Payment?
**An x402 payment has three roles: a client that pays, a resource server that sells, and a facilitator that verifies and settles.** The facilitator is the part that makes the protocol practical, because it lets a seller accept payments without running blockchain infrastructure.
```mermaid
graph TD
subgraph BUY["Buyer side"]
U["A person or company
sets the budget"] --> AG["AI agent
makes the request"]
AG --> W["Wallet
signs the payment"]
end
subgraph SELL["Seller side"]
RS["Resource server
page, API, dataset or tool"]
SW["Seller wallet
receives the money"]
end
subgraph MID["Shared infrastructure"]
FA["Facilitator
verifies and settles"]
NET["Payment network
records the transfer"]
end
W -->|"signed request"| RS
RS -->|"verify, then settle"| FA
FA --> NET
NET --> SW
style BUY fill:#0a1420,stroke:#1a2a45
style SELL fill:#0a1a14,stroke:#1b3d2a
style MID fill:#1a140a,stroke:#3a2a1a
style AG fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style U fill:#1e1e2e,color:#94a3b8,stroke:#475569
style W fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style RS fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style SW fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style FA fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style NET fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
```
| Role | What it does | Who plays it today |
|---|---|---|
| Client | Requests the resource, reads the price, signs the payment | An AI agent, a script or an app with a wallet |
| Resource server | Sets the price, returns 402, serves the resource after payment | An API, a website, a dataset or an [MCP server](https://www.taskade.com/blog/mcp-servers) |
| Facilitator | Verifies the signed payment and settles it on a network | Coinbase runs one. The agenteconomy.to tracker lists 18 |
| Payment network | Records the final transfer | Base and Solana carry most volume today |
Two facts about facilitators deserve attention. Settlement in x402 is peer to peer: the money goes to the seller's wallet, and the facilitator does not hold it ([Cloudflare](https://blog.cloudflare.com/monetization-gateway/)). And the facilitator is a service a seller chooses, not a single company. The [agenteconomy.to tracker](https://agenteconomy.to/x402) counted 18 facilitators across 12 chains on November 12, 2026.
On networks and currencies, the Coinbase documentation says x402 runs on EVM networks and Solana, and that USDC is the most common asset, though a seller can accept other tokens ([Coinbase docs](https://docs.cdp.coinbase.com/x402/core-concepts/how-it-works)). Cloudflare's wording is the most useful summary: "x402 is rail agnostic, but it is a natural fit for stablecoins."
---
## 🧮 Which Payment Schemes Does x402 Support?
**x402 supports more than a fixed price per request.** The V2 documentation names three settlement schemes: `exact`, `upto` and `batch-settlement` ([x402 docs](https://docs.x402.org/core-concepts/http-402)). Coinbase describes the same three in plain words: a fixed price, a maximum that settles only what was used, and settlement deferred for a batch. The [V2 specification](https://github.com/coinbase/x402/blob/main/specs/x402-specification-v2.md) lists a fourth, `auth-capture`.
| Scheme | How it charges | Good fit |
|---|---|---|
| `exact` | The client pays the stated price | A page, a lookup, a fixed API call |
| `upto` | The client authorizes a maximum and the server settles actual use | Work whose cost is unknown up front, such as file conversion |
| `batch-settlement` | Many small charges settle together later | High-frequency calls where each transfer is too small to settle alone |
| Deferred, proposed by Cloudflare | A signed commitment now, settlement later over cards or stablecoins | Crawlers with a licensing agreement, batch settlement or a subscription |
The deferred idea comes from [Cloudflare's September 2025 x402 post](https://blog.cloudflare.com/x402/), which describes a scheme "specifically designed for agentic payments that don't need immediate settlement." It separates the cryptographic handshake from the money movement, so two companies can agree on terms once and settle later in a batch or through a subscription.
Those schemes let a seller express real pricing models. Cloudflare's Monetization Gateway announcement gives examples of the rules a seller can write:
| Pricing model | Cloudflare's example |
|---|---|
| Per call | A few cents per web search |
| Base fee plus metered use | $0.001 base plus $0.01 per MB for an upload endpoint |
| Outcome based | $0.99 per resolved support escalation, charged only on success |
| Per route and method | $0.01 per GET or POST to a premium path |
| Variable | Image generation priced up to $2, based on compute used |
Outcome pricing is the interesting row. A server that charges only when the work succeeds matches how teams already judge AI by [cost per task](https://www.taskade.com/blog/ai-cost-per-task) instead of cost per token. The same logic runs through [AI inference](https://www.taskade.com/blog/ai-inference-explained): the unit that matters is the finished job.
---
## 🆚 x402 V1 vs V2: What Changed?
**x402 V2 moved payment data out of the response body and into three standard headers.** The x402 team launched V2 in December 2025 after about six months of production use, and reported that the protocol had processed "over 100M payments" by then ([x402.org](https://www.x402.org/writing/x402-v2-launch)).
| Area | V1 | V2 |
|---|---|---|
| Price terms | In the 402 response body | `PAYMENT-REQUIRED` header, so the body is free for a human-readable page |
| Payment proof | `X-PAYMENT` header | `PAYMENT-SIGNATURE` header |
| Receipt | `X-PAYMENT-RESPONSE` header | `PAYMENT-RESPONSE` header |
| Networks | Named per implementation | CAIP identifiers for chains and assets |
| New chains and schemes | Changes inside the SDK | A plugin design: developers register chains, assets and schemes |
| Recipient | Fixed per endpoint | Per-request routing to addresses, roles or payout logic |
| Finding paid services | Not in the protocol | A Discovery extension that facilitators can index |
The V2 post also describes a wallet sign-in feature, which lets a client prove it controls a wallet and reach a resource it already bought without paying again. The post lists that feature as a fast follow, not as part of the first V2 release. According to the same post, the reference SDKs stay "fully backward-compatible with V1."
Because the price now travels in a header, a server can return a normal web page in the body of the 402 response. A person who lands on the URL sees an explanation. An agent reads the header and pays.
---
## 🕷️ What Is Cloudflare Pay Per Crawl?
**Pay per crawl is a Cloudflare feature that lets a site charge AI crawlers for each page they fetch.** [Cloudflare announced it on July 1, 2025](https://blog.cloudflare.com/introducing-pay-per-crawl/) as a private beta. Cloudflare's documentation, updated on July 28, 2026, still describes it as a [closed beta](https://developers.cloudflare.com/ai-crawl-control/features/pay-per-crawl/what-is-pay-per-crawl/).
Pay per crawl uses status code 402, but it is not x402. It has its own headers and its own money flow. Cloudflare is the merchant of record: it charges the crawler's account and pays the publisher.
```mermaid
sequenceDiagram
participant B as AI crawler
participant E as Cloudflare edge
participant O as Publisher site
B->>E: GET /article, signed with Web Bot Auth
E-->>B: 402 Payment Required, crawler-price USD 0.01
B->>E: GET /article, crawler-exact-price USD 0.01
E->>O: Forward the request
O-->>E: The page
E-->>B: 200 OK, crawler-charged USD 0.01
Note over B,E: Cloudflare records a billing event
Note over E,O: Cloudflare pays the publisher later
```
The `USD 0.01` value above is the example Cloudflare uses in its documentation, not a recommended price.
| Header | Sent by | Meaning |
|---|---|---|
| `crawler-price` | Cloudflare, with a 402 | The price for this page |
| `crawler-exact-price` | Crawler, on a retry | "I agree to pay this exact price" |
| `crawler-max-price` | Crawler, up front | "I will pay up to this much" |
| `crawler-charged` | Cloudflare, with a 200 | The amount charged |
A crawler can avoid the first failed request. If it sends `crawler-max-price` with its first request and the page costs that much or less, it receives the page at once and pays only the configured price.
A site owner chooses one of three settings for each crawler. The setting applies only after the site's firewall and bot rules run.
```mermaid
graph TD
R["An AI crawler requests a page"] --> Q{"What did the site owner
set for this crawler?"}
Q -->|"Allow"| AL["200 OK
free access"]
Q -->|"Charge"| CH{"Did the crawler
state a price?"}
Q -->|"Block"| BL["Blocked
no access"]
CH -->|"Yes, and it covers the price"| PAID["200 OK
with crawler-charged"]
CH -->|"No"| NOPAY["402 Payment Required
with crawler-price"]
style R fill:#1e1e2e,color:#94a3b8,stroke:#475569
style Q fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style CH fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style AL fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style PAID fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style NOPAY fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style BL fill:#1a0d0d,color:#ef9a9a,stroke:#b71c1c,stroke-width:1.5px
```
Identity is the hard part of charging a crawler, because a user-agent string is easy to fake. Pay per crawl relies on [Web Bot Auth](https://blog.cloudflare.com/web-bot-auth/): the crawler signs each request with a private key, and Cloudflare checks the signature against a public key the crawler operator has registered. Our guide to [AI web scraping](https://www.taskade.com/blog/ai-web-scraping) covers the other side of that relationship, the tools that fetch pages.
Pay per crawl lives inside a larger product called [AI Crawl Control](https://developers.cloudflare.com/ai-crawl-control/), formerly AI Audit. Its monitoring and allow or block controls are available on all Cloudflare plans. Only the pricing part is in beta.
---
## 🚪 What Is the Cloudflare Monetization Gateway?
**The Monetization Gateway is Cloudflare's x402 product: it lets a site owner charge AI agents for any resource behind Cloudflare.** Cloudflare [announced it on July 1, 2026](https://blog.cloudflare.com/monetization-gateway/) with a waitlist and [opened a closed beta on September 30, 2026](https://blog.cloudflare.com/monetization-gateway-beta). The beta is limited to eligible sellers and buyers in the United States, and payments settle in USDC on the Base network through Coinbase's x402 facilitator.
Where pay per crawl prices a page for a crawler, the gateway prices a request for an agent. The announcement lists four kinds of resource: web pages, datasets, APIs and MCP tools. The seller writes payment rules, and Cloudflare checks payment at its edge before the request reaches the seller's server.
```mermaid
graph TD
AG["AI agent sends a request"] --> ED["Cloudflare edge
330+ cities"]
ED --> RULE{"Does a payment rule
match this request?"}
RULE -->|"No rule"| ORI["Origin server
serves the resource"]
RULE -->|"Rule matches"| PAY{"Does the request
carry valid payment?"}
PAY -->|"No"| R402["402 Payment Required
price, asset, destination"]
PAY -->|"Yes"| FAC["Facilitator verifies
and settles"]
FAC --> ORI
ORI --> OUT["Response returns to the agent"]
style AG fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style ED fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style RULE fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style PAY fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style R402 fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style FAC fill:#11111b,color:#cdd6f4,stroke:#00d4aa
style ORI fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style OUT fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
```
The value for a seller is that payment logic leaves the application. In Cloudflare's words, "the metering, the payment exchange, and the settlement move off your origin." A team that already runs an API does not have to write billing code to sell it to agents. The July 2026 announcement also describes a planned rule that turns a 401 Unauthorized response from the origin into a 402, so known customers keep using their accounts and unknown agents get a price. The beta documentation does not list that rule yet.
The beta post names four live uses. They show what "a resource an agent will pay for" looks like in practice.
| Seller | What an agent buys | Pricing detail from Cloudflare's post |
|---|---|---|
| Cloudflare AI Gateway | Inference on a select set of models | Pay per request with a payment header, in place of a prepaid credit balance |
| Ceramic.ai | Web search over an index of more than 40 billion pages | Fixed price, no API key |
| Stocktwits | Market sentiment and trending data | Each request priced individually |
| API2PDF | PDF generation | Variable price: the agent sees a maximum and pays for actual use |
API2PDF's reason for joining is the clearest business case in the post. The company reported that requiring a credit card after the first month caused a drop of more than 50% in conversion. A price in the response removes that step for a customer who is software. The inference example connects to a wider trend we cover in [inference as a service](https://www.taskade.com/blog/inference-as-a-service): compute sold by the request.
### Pay per crawl vs Monetization Gateway vs Pay Per Use
**Cloudflare now has three ways to charge AI systems, and each one prices a different event.** Pay per crawl charges for access. The Monetization Gateway charges per request. [Pay Per Use](https://blog.cloudflare.com/pay-per-use), in beta since September 30, 2026, charges for what an AI company does with content after it has it.
| | Pay per crawl | Monetization Gateway | Pay Per Use |
|---|---|---|---|
| What is priced | A crawler's page fetch | An agent's request | Each reported use of content |
| Protocol | Cloudflare's crawler headers | x402 | A reporting API |
| Who moves the money | Cloudflare, as merchant of record | Buyer wallet to seller wallet | Cloudflare bills buyers and pays publishers |
| Status in November 2026 | Closed beta | Closed beta, United States | Beta |
| Best fit | Publishers with many crawled pages | APIs, tools and data | News and research used many times after one fetch |
```mermaid
graph TD
Q1{"What do AI systems
take from you?"} -->|"They crawl my pages"| Q2{"Is the value in the fetch
or in the later use?"}
Q1 -->|"They call my API,
tool or dataset"| MG["Monetization Gateway
price each request with x402"]
Q2 -->|"The fetch"| PPC["Pay per crawl
price each page fetch"]
Q2 -->|"The later use"| PPU["Pay Per Use
buyers report and pay per use"]
Q1 -->|"I want them to read me
for free"| FREE["Allow, and publish
llms.txt and Markdown"]
style Q1 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style Q2 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style MG fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style PPC fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style PPU fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style FREE fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
```
---
## 👛 How Do AI Agents Hold Money and Prove Who They Are?
**An agent pays with a wallet a person funds and limits, and it proves its identity with a signed request.** Payment and identity are two separate layers. A payment proves that someone paid. It does not prove who.
On the payment side, [Cloudflare Wallets](https://blog.cloudflare.com/wallets/), announced on August 4, 2026, shows the shape most vendors are building toward. A person or company holds an Account Wallet and can add or withdraw funds. Each agent gets a Virtual Wallet, reached through an API key, with a ceiling the owner sets.
```mermaid
graph TD
H["Account owner
a person or a finance team"] --> AW["Account Wallet
holds the funds"]
AW --> V1["Virtual Wallet
research agent"]
AW --> V2["Virtual Wallet
support agent"]
AW --> V3["Virtual Wallet
coding agent"]
V1 --> G["Guardrails
spending budget, an allow list,
maximum size per payment"]
V2 --> G
V3 --> G
G --> X["Paid requests over x402"]
G --> HR["Over the limit
a person must approve"]
style H fill:#1e1e2e,color:#94a3b8,stroke:#475569
style AW fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style V1 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style V2 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style V3 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style G fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style X fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style HR fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
```
Cloudflare's post lists three example guardrails: a spending budget, an allow list and a cap on the size of each payment. Going over a limit needs a person to approve. On the announcement date, the only live part was claiming a handle. Funding and payments were listed as coming later, so treat this as a design, not a finished product.
On the identity side, three efforts use the same building block, signed HTTP messages:
| Effort | What it proves | Source |
|---|---|---|
| Web Bot Auth | This request comes from the bot operator that owns this key | [Cloudflare, May 15, 2025](https://blog.cloudflare.com/web-bot-auth/) |
| Visa Trusted Agent Protocol | This agent is trusted and acts for a real buyer | [Visa, October 14, 2025](https://usa.visa.com/about-visa/newsroom/press-releases.releaseId.21716.html) |
| Google AP2 mandates | A person signed this instruction to buy | [Google Cloud, September 16, 2025](https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol) |
The guardrails matter more than the payment rail. An agent that runs for hours, such as the [always-on agents](https://www.taskade.com/blog/always-on-ai-agents) and [AI claws](https://www.taskade.com/blog/ai-claws) we have written about, can make thousands of requests without a person watching. The same care that goes into an [agent sandbox](https://www.taskade.com/blog/ai-agent-sandboxes) or an [agent harness](https://www.taskade.com/blog/agent-harness-explained) applies to a budget: decide the limit before the agent starts.
---
## ⚔️ x402 vs ACP vs AP2 vs MCP vs L402 vs API Keys
**x402 is one of several agent payment standards, and most of them do different jobs.** x402 moves a small payment inside a request. Other standards handle a shopping checkout, prove that a person authorized a purchase, or connect an agent to tools with no payment at all.
| Standard | Started by | What it does | Money rail |
|---|---|---|---|
| x402 | Coinbase, May 2025 | Pays for a resource inside an HTTP request | Stablecoins today, designed to be rail agnostic |
| Pay per crawl | Cloudflare, July 2025 | Charges a crawler per page fetch | Cloudflare bills and pays out |
| ACP | Stripe and OpenAI, September 2025 | Runs a checkout between an agent and a merchant | Card and payment processor rails |
| AP2 | Google, September 2025 | Records signed proof of what a person authorized | Cards, bank transfers and stablecoins |
| UCP | Shopify and Google, January 2026 | Lets an agent search a catalog, build a cart and check out | The merchant's own checkout |
| L402 | Lightning Labs | Pays for an API with Bitcoin Lightning and a token | Bitcoin Lightning |
| MCP | Anthropic | Connects an agent to tools and data | None in the base protocol |
| API key | Common practice | Identifies a paying account | A monthly invoice or prepaid credits |
A second table answers the question a builder asks: when would I use each one?
| If the agent needs to... | Use | Why |
|---|---|---|
| Pay one cent for one API call with no account | x402 | The payment is the credential |
| Buy a physical product from a store | ACP or UCP | The merchant stays merchant of record and handles orders |
| Prove a person approved a purchase | AP2 | Signed mandates create an audit trail |
| Call a tool or read a database | MCP | It is the connection layer |
| Pay for a tool call over MCP | MCP plus x402 | Cloudflare's Agents SDK wraps MCP tools with x402 prices |
| Use a service your company already pays for | An API key | No per-request payment is needed |
These standards stack more than they compete. Google worked with Coinbase on an x402 extension for agent-to-agent payments when it announced AP2. Visa said it is aligning its Trusted Agent Protocol with x402. Cloudflare added x402 to MCP in its Agents SDK. The picture is a set of layers.
```mermaid
graph TD
L5["Authorization
AP2 mandates: did a person approve this?"] --> L4["Checkout
ACP and UCP: cart, order, fulfillment"]
L4 --> L3["Payment in the request
x402, pay per crawl, L402"]
L3 --> L2["Identity
Web Bot Auth, Trusted Agent Protocol"]
L2 --> L1["Connection
HTTP and MCP"]
style L5 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style L4 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style L3 fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style L2 fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style L1 fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
```
For the connection layer, our guides to [MCP](https://www.taskade.com/blog/mcp) and the wiki entry on [MCP vs API](https://www.taskade.com/wiki/ai/mcp-vs-api) explain how agents reach tools. For the commerce layer, see the wiki entry on [agentic commerce](https://www.taskade.com/wiki/ai/agentic-commerce) and our [history of Shopify](https://www.taskade.com/blog/history-of-shopify), which covers the Universal Commerce Protocol that Shopify and Google launched in January 2026. L402, the Lightning-based design, is documented by [Lightning Labs](https://docs.lightning.engineering/the-lightning-network/l402), and the Agentic Commerce Protocol has its own site at [agenticcommerce.dev](https://www.agenticcommerce.dev/).
---
## 📊 How Much Money Moves Over x402 Today?
**x402 has processed a large number of transactions and a small amount of money.** The public tracker [agenteconomy.to](https://agenteconomy.to/x402) showed 199,419,047 lifetime transactions and $42,833,895 settled across 12 chains on November 12, 2026. That works out to about 21 cents per transaction.
The lifetime count hides the trend. A [Fireblocks analysis reported by Blockchain.News on November 3, 2026](https://blockchain.news/news/agent-economy-data-points-show-growth-but-payment-metrics-remain-noisy) found that more than half of all lifetime transactions came from a two-month burst in late 2025, tied to a token that was minted through x402. That activity was not agents buying services.
```mermaid
xychart-beta
title "x402 transactions in three reported months"
x-axis "Month" [Nov 2025, Dec 2025, Oct 2026]
y-axis "Transactions, millions" 0 --> 60
bar [52.6, 54.2, 5.1]
```
```mermaid
xychart-beta
title "x402 settled value in three reported months"
x-axis "Month" [Nov 2025, Dec 2025, Oct 2026]
y-axis "US dollars, millions" 0 --> 22
bar [20.5, 9.4, 0.27]
```
| Measure | Value | Source and date |
|---|---|---|
| Lifetime transactions | 199,419,047 | agenteconomy.to, November 12, 2026 |
| Lifetime settled value | $42,833,895 | agenteconomy.to, November 12, 2026 |
| Chains and facilitators tracked | 12 chains, 18 facilitators | agenteconomy.to, November 12, 2026 |
| November 2025 | 52.6 million transactions, $20.5 million | Fireblocks, via Blockchain.News |
| December 2025 | 54.2 million transactions, $9.4 million | Fireblocks, via Blockchain.News |
| October 2026 | 5.1 million transactions, $274,000 | Fireblocks, via Blockchain.News |
| Share by chain, to date | Base about 45%, Solana about 34% | Fireblocks, via Blockchain.News |
Read those numbers with two cautions. The tracker itself says its totals are "visible protocol activity" and can include tests, infrastructure traffic and self-directed use. And different trackers report different dollar values for the same month, because they filter that activity in different ways.
The fair summary: the plumbing is real, the membership is serious, and the commerce is early. October 2026 moved $274,000 across the whole protocol, which is a small sum for a system with 40 member organizations behind it. Anyone who tells you agent payments are already a large market is ahead of the data.
---
## 🏗️ Who Gets Paid in the Agent Internet?
**Money in the agent internet flows to whoever owns a resource an agent cannot do its job without.** A useful way to see it is as a stack. The model answers the question, but the model needs inputs, and each input can sit behind a price.
```mermaid
graph TD
U["A person asks an agent
to do a job"] --> M["The model
paid per token"]
M --> T["Tools the agent calls
search, conversion, code
paid per call"]
M --> D["Data the agent reads
prices, filings, records
paid per lookup"]
M --> P["Pages the agent fetches
articles, docs, catalogs
paid per crawl or free"]
T --> F["Facilitators and networks
settle each payment"]
D --> F
P --> F
F --> S["Sellers receive the money"]
style U fill:#1e1e2e,color:#94a3b8,stroke:#475569
style M fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style T fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style D fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style P fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style F fill:#11111b,color:#cdd6f4,stroke:#00d4aa
style S fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
```
| Layer | Who is paid | Unit of sale | Example |
|---|---|---|---|
| Model | AI labs and inference providers | Tokens | A chat or agent step |
| Tools | API and tool vendors | A call or an outcome | API2PDF's PDF generation |
| Data | Owners of clean, fresh datasets | A lookup | Stocktwits' sentiment data |
| Pages | Publishers | A fetch or a use | A news archive behind pay per crawl |
| Settlement | Networks and facilitators | A network fee | Base, Solana |
The model layer already works this way. Every answer is billed by the token, and the physical cost behind each token is the subject of our guide to [AI data centers](https://www.taskade.com/blog/ai-data-centers-explained). x402 extends that meter outward, from the model to everything the model reads and calls.
Two things follow. First, a general web page is the weakest position in the stack, because an agent can often find the same fact elsewhere for free. Second, the strongest position belongs to data that is valuable, changes often and is hard to collect. That observation leads straight to what builders are doing with x402.
---
## 🌐 What Should Site Owners Do About AI Agents?
**Most site owners should make their site easy for agents to read before they think about charging.** The decisions form a ladder. Each rung is useful alone, and pricing is the top rung, not the first.
```mermaid
graph TD
S1["Rung 1: robots.txt
say which crawlers may read what"] --> S2["Rung 2: see the traffic
measure which AI crawlers visit"]
S2 --> S3["Rung 3: llms.txt
give agents a map of the site"]
S3 --> S4["Rung 4: Markdown and structure
clean text, schema, clear pricing pages"]
S4 --> S5["Rung 5: tools
a search endpoint or an MCP server"]
S5 --> S6["Rung 6: a price
pay per crawl or x402, where it fits"]
style S1 fill:#1e1e2e,color:#94a3b8,stroke:#475569
style S2 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style S3 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style S4 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style S5 fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
style S6 fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
```
| Rung | What you do | Tool or standard | Cost |
|---|---|---|---|
| 1 | Write clear crawler rules | robots.txt | Free. See our guide to [AI robots.txt generators](https://www.taskade.com/blog/ai-robots-txt-generators) |
| 2 | Measure AI crawler traffic | Server logs or AI Crawl Control | Free on all Cloudflare plans |
| 3 | Publish a map for language models | [llms.txt](https://llmstxt.org/), proposed September 3, 2024 | Free |
| 4 | Serve clean text | Markdown copies, schema markup, [Markdown for Agents](https://blog.cloudflare.com/markdown-for-agents/) | Low |
| 5 | Offer a tool | A search API or an MCP server | Engineering time |
| 6 | Set a price | Pay per crawl or an x402 gateway | Beta access today |
The reason to climb in order is simple. A price on a page that agents cannot parse earns nothing. And for most businesses, the goal of a website is to win customers. If an AI assistant reads your pricing page and recommends you, that is worth far more than a fraction of a cent per fetch.
**When does a price make sense?** Use this test:
- **Charge** when the content is the product: news, research, market data, a licensed archive.
- **Stay free** when the content sells something else: product pages, documentation, comparison guides, help articles.
- **Split** when you have both: keep the marketing site open and put the dataset or the API behind a price.
We follow the free path on taskade.com, and we use the lower rungs ourselves. The site publishes an [llms.txt](https://www.taskade.com/llms.txt) file, serves a Markdown copy of each documentation, help and blog article, and has Markdown for Agents turned on. A hosted MCP server, described in the [Taskade MCP documentation](https://www.taskade.com/docs/mcp/hosted-mcp) and included in every paid plan, gives agents a direct way to work with a workspace. None of the reading surfaces has a price, because we want agents to understand the product.
Cloudflare's [AI Index](https://blog.cloudflare.com/an-ai-index-for-all-our-customers/), in private beta since September 26, 2025, packages rungs 3 to 5 for sites on its network: it builds an MCP server, llms.txt files, a search API, a bulk data API and change notifications for a domain. It is a sign that these rungs are becoming standard parts of a website.
---
## 💡 What Are People Building on Top of x402?
**Builders are packaging clean, structured resources that agents need, and adding a price later.** The clearest public list comes from investor and podcast host Greg Isenberg, who described three business shapes in an [August 2026 episode](https://www.youtube.com/watch?v=MNNfat_QP0E). His one-line model in the episode: "The human web monetized attention, and the agent web monetizes useful resources." The sellers that are live today are in the [Monetization Gateway section](#what-is-the-cloudflare-monetization-gateway) above: a web search index, a market data feed, a PDF conversion API and an AI model gateway.
These are his ideas and his price estimates, not forecasts from us. They are useful because they show what a resource worth paying for looks like.
| Business shape | What it sells | First customer, in his telling | How it starts |
|---|---|---|---|
| Niche data refinery | Clean, fresh data about one small market | Agencies and consultants who already sell to that market | A spreadsheet of 100 businesses, kept by hand |
| Agent readiness service | A site that AI systems can read, trust and compare | A company whose pricing or docs AI gets wrong | A paid audit of what AI says about the company today |
| Expert archive as a tool | One expert's knowledge, packaged for one job | The expert's existing audience | Transcripts tagged by task, with one workflow |
His filter for the first idea is the most reusable part. Data is worth refining when it is valuable, needed again and again, changing, fragmented across many sources, and annoying to collect. The last word is the margin.
All three ideas share a path, and x402 is the final step, not the first.
```mermaid
graph TD
P1["A manual service
sold to people today"] --> P2["A report or a dashboard"]
P2 --> P3["An API"]
P3 --> P4["An MCP tool
agents can call it"]
P4 --> P5["A price per request
with x402, when buyers are ready"]
style P1 fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style P2 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style P3 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style P4 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style P5 fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
```
That order is sound advice whatever happens to agent payments. Each business works as a service for human customers now. If agents become real buyers, the same data gets a second kind of customer. For more on small teams building this way, see [one-person companies](https://www.taskade.com/blog/one-person-companies) and [AI agents for solopreneurs](https://www.taskade.com/blog/ai-agents-solopreneurs).
### Where does a workspace fit?
**Each of those three businesses is a store of structured data, an agent that reads it, and an automation that keeps it fresh.** That is the same shape as a workspace app. In [Taskade Genesis](https://www.taskade.com/create), a project holds the records, an [AI agent](https://www.taskade.com/agents) works on them, and an [automation](https://www.taskade.com/automate) runs on a schedule and writes the results back.
```mermaid
sequenceDiagram
participant A as Automation
participant G as AI agent
participant W as The web
participant P as Project table
A->>G: Scheduled run starts
G->>W: Read public pages for each business
W-->>G: Prices, services, reviews
G->>P: Update the matching rows
P-->>G: Rows that changed
G->>A: Write a summary
A->>P: Save the weekly report
```
To be exact about what exists today: Taskade does not support x402 payments or agent wallets. An automation can call an external API with the HTTP Request step and reach MCP tools with the MCP Client connector, and both run on every plan, Free included. Access to outside services still uses the keys and accounts you provide. What a workspace gives you now is the first three steps of the path above: the data, the agent and the refresh loop. You can browse working examples in the [Taskade App Factory](https://www.taskade.com/apps) or start from the [AI app builder](https://www.taskade.com/ai/apps).
---
## 🚧 What Are the Limitations and Open Questions?
**x402 works as a protocol, and it still has open problems in volume, access, identity and trust.** An honest explainer should list them.
| Open question | What we know in November 2026 |
|---|---|
| Is there real demand? | October 2026 saw $274,000 in settled value across the protocol, per Fireblocks. Early |
| Can anyone use Cloudflare's products? | No. Pay per crawl and the Monetization Gateway are closed betas. The gateway is limited to the United States |
| Does it need crypto? | In practice, yes today. Payments settle in stablecoins. Card and bank rails are possible in V2 through facilitators |
| Who is the agent? | A payment does not identify the payer. Identity standards such as Web Bot Auth are separate and still drafts |
| What stops a runaway agent? | Wallet guardrails. Cloudflare Wallets listed budgets and approval steps as planned, not live, at announcement |
| What about refunds and disputes? | The base protocol defines payment and settlement. It does not define chargebacks |
| Will crawlers pay? | Unknown. A large AI company can decline to pay and skip the site |
| Will sites lose AI visibility? | Possibly. A site that charges or blocks may be cited less in AI answers |
Three points deserve a longer note.
**Security is an active research area.** Sessions and wallet sign-in reduce repeated payments, and they also create tokens that can leak. Any team that accepts x402 should log each payment's scheme, amount, network and settlement status, keep the raw `PAYMENT-*` header values out of its logs because `PAYMENT-SIGNATURE` carries a signed payment authorization, and treat a paid endpoint with the same care as a login.
**The buyer has to exist.** A price is only useful if agents carry wallets. That is why the wallet products matter more than the gateway products, and why the 2026 numbers are small. Sellers are ready before buyers.
**Pricing knowledge is hard.** Nobody knows what a page is worth to an agent. Too high, and the agent goes elsewhere. Too low, and the fee does not cover the lost visit. Expect years of experiments.
The same uncertainty applies to builders. If you start a data business because of x402, make sure it earns money from people first.
---
## 📖 x402 Glossary: Terms in Plain English
| Term | Meaning |
|---|---|
| HTTP 402 | The status code "Payment Required", reserved since 1997 |
| x402 | An open protocol that uses 402 to request and accept payment in an HTTP exchange |
| Facilitator | A service that verifies a signed payment and settles it for the seller |
| Resource server | The API, site or tool that sets a price and serves the resource |
| Scheme | The charging rule, such as `exact`, `upto`, `batch-settlement` or `auth-capture` |
| Stablecoin | A digital token designed to hold the value of a currency, such as USDC for the US dollar |
| Pay per crawl | Cloudflare's feature for charging AI crawlers per page fetch |
| Monetization Gateway | Cloudflare's product for charging agents per request with x402 |
| Web Bot Auth | A proposal for bots and agents to sign requests so a site can verify the sender |
| llms.txt | A proposed file that gives language models a short map of a site |
| MCP | Model Context Protocol, a standard for connecting agents to tools and data |
| Merchant of record | The party that legally sells to the buyer and handles the payment |
For more agent vocabulary, the [agentic AI glossary](https://www.taskade.com/blog/agentic-ai-glossary) covers the terms around planning, memory and tools.
---
## 🔗 Related Reading
- [What Are AI Agents?](https://www.taskade.com/blog/what-are-ai-agents): the buyers in this story
- [Browser Agents Explained](https://www.taskade.com/blog/browser-agents-explained): how agents use sites that have no API
- [The History of Browserbase](https://www.taskade.com/blog/history-of-browserbase): infrastructure for agents that browse
- [Best MCP Servers](https://www.taskade.com/blog/mcp-servers) and [the Taskade MCP server](https://www.taskade.com/blog/taskade-mcp-server): the tool layer agents call
- [Agentic Workspaces](https://www.taskade.com/blog/agentic-workspaces): where agents, data and automations live together
- [100+ integrations](https://www.taskade.com/integrations): the services an automation can reach today (premium integrations need a paid plan)
---
## 💬 Frequently Asked Questions About x402
### What is x402?
x402 is an open payment protocol that lets software pay for a web resource inside a normal HTTP request. A server answers an unpaid request with status code 402 Payment Required and a price. The client signs a payment, sends the request again with proof, and receives the resource. Coinbase announced x402 on May 6, 2025.
### Who created x402?
The Coinbase Developer Platform team created x402. The whitepaper lists six authors: Erik Reppel, Ronnie Caspers, Kevin Leffew, Dan Kim, Nemil Dalal and Danny Organ. Cloudflare and Coinbase announced plans for an x402 Foundation on September 23, 2025, the Linux Foundation announced it on April 2, 2026, and it started operations on July 14, 2026 with 40 member organizations.
### Is x402 a cryptocurrency or a token?
No. x402 is a protocol, not a coin. It describes how a server asks for payment and how a client proves it paid. The protocol charges no fee of its own. Most x402 payments today settle in the USDC stablecoin, and the design allows other payment rails.
### How does an x402 payment work?
An x402 payment takes two requests. The server replies to the first with 402 and a `PAYMENT-REQUIRED` header that states the price. The client retries with a signed payment in a `PAYMENT-SIGNATURE` header. A facilitator verifies and settles the payment, and the server returns the resource with a `PAYMENT-RESPONSE` header.
### What is pay per crawl?
Pay per crawl is a Cloudflare feature, announced on July 1, 2025, that lets a site charge AI crawlers for each page they fetch. A crawler that has not agreed to pay receives 402 with a `crawler-price` header. Cloudflare bills the crawler and pays the publisher. The feature is still a closed beta.
### Is pay per crawl the same as x402?
No. Both use status code 402, but pay per crawl uses Cloudflare's own headers, and Cloudflare is the merchant of record. x402 is an open protocol in which money moves from the buyer's wallet to the seller's wallet through a facilitator. Cloudflare's Monetization Gateway is the product that uses x402.
### What is the Cloudflare Monetization Gateway?
The Monetization Gateway lets a site owner charge AI agents for web pages, datasets, APIs and MCP tools with x402. Cloudflare announced it on July 1, 2026 and opened a closed beta on September 30, 2026 for eligible sellers and buyers in the United States. Beta payments settle in USDC on Base.
### Do AI agents need a crypto wallet to use x402?
Today, yes. An x402 buyer needs a wallet that can sign a payment, and most payments settle in stablecoins. Products such as Cloudflare Wallets aim to hide that step: a person funds an account wallet and gives each agent a virtual wallet with a limit.
### Should my website charge AI crawlers?
It depends on what your site sells. If the content is the product, a price can replace lost visits. If the site exists to win customers, being read and cited by AI systems is worth more than a small fee. Most sites should publish clear robots.txt rules, an llms.txt file and clean Markdown first.
### How is x402 different from ACP, AP2 and MCP?
x402 moves a small payment inside an HTTP request. The Agentic Commerce Protocol handles a shopping checkout between an agent and a merchant. Google's AP2 records signed proof that a person authorized a purchase. MCP connects an agent to tools and has no payment step. One task can use several of them.
### How much is x402 used in 2026?
The tracker agenteconomy.to showed about 199 million lifetime transactions and about $42.8 million settled on November 12, 2026. A Fireblocks analysis counted 5.1 million transactions worth $274,000 in October 2026, and said more than half of lifetime transactions came from a token minting burst in late 2025.
### Can a Taskade automation call a paid API or an MCP tool?
Yes. A Taskade automation can call an external API with the HTTP Request step and reach MCP tools with the MCP Client connector, on every plan. x402 payments and agent wallets are not part of Taskade today. Outside services still use the keys or accounts you provide.
---
## 🧾 Sources
All facts in this guide were checked on November 12, 2026.
- IETF, [RFC 2068, section 10.4.3](https://www.rfc-editor.org/rfc/rfc2068#section-10.4.3) (January 1997) and [RFC 9110, section 15.5.3](https://www.rfc-editor.org/rfc/rfc9110.html#name-402-payment-required) (June 2022)
- MDN, [402 Payment Required](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/402)
- x402 Foundation, [x402.org](https://www.x402.org/), [the x402 V2 launch post](https://www.x402.org/writing/x402-v2-launch), [the HTTP 402 documentation](https://docs.x402.org/core-concepts/http-402) and the [whitepaper](https://www.x402.org/x402-whitepaper.pdf)
- Coinbase Developer Platform, [how x402 works](https://docs.cdp.coinbase.com/x402/core-concepts/how-it-works) and the [x402 repository](https://github.com/coinbase/x402)
- Linux Foundation, [operational launch of the x402 Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-operational-launch-of-x402-foundation-to-standardize-internet-native-payments-for-ai-agents-and-applications) (July 14, 2026)
- Cloudflare, [Introducing pay per crawl](https://blog.cloudflare.com/introducing-pay-per-crawl/), [Content Independence Day](https://blog.cloudflare.com/content-independence-day-no-ai-crawl-without-compensation/), [Launching the x402 Foundation with Coinbase](https://blog.cloudflare.com/x402/), [An AI Index for all our customers](https://blog.cloudflare.com/an-ai-index-for-all-our-customers/), [Announcing the Monetization Gateway](https://blog.cloudflare.com/monetization-gateway/), [Monetization Gateway beta](https://blog.cloudflare.com/monetization-gateway-beta), [Pay Per Use](https://blog.cloudflare.com/pay-per-use), [Cloudflare Wallets](https://blog.cloudflare.com/wallets/), [Web Bot Auth](https://blog.cloudflare.com/web-bot-auth/) and [Markdown for Agents](https://blog.cloudflare.com/markdown-for-agents/)
- Cloudflare developer documentation, [AI Crawl Control](https://developers.cloudflare.com/ai-crawl-control/), [What is pay per crawl?](https://developers.cloudflare.com/ai-crawl-control/features/pay-per-crawl/what-is-pay-per-crawl/) and [Monetization Gateway](https://developers.cloudflare.com/monetization-gateway/)
- Cointelegraph, [Coinbase x402 payments protocol](https://cointelegraph.com/news/coinbase-x402-payments-protocol-make-ai-agents-more-autonomous) (May 2025)
- Google Cloud, [Agent Payments Protocol (AP2)](https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol) (September 16, 2025)
- Stripe, [Instant Checkout and the Agentic Commerce Protocol](https://stripe.com/newsroom/news/stripe-openai-instant-checkout) (September 29, 2025)
- Visa, [Trusted Agent Protocol](https://usa.visa.com/about-visa/newsroom/press-releases.releaseId.21716.html) (October 14, 2025)
- Agent Economy, [x402 tracker](https://agenteconomy.to/x402) (read November 12, 2026)
- Blockchain.News, [Agent economy data points show growth, but payment metrics remain noisy](https://blockchain.news/news/agent-economy-data-points-show-growth-but-payment-metrics-remain-noisy) (November 3, 2026, reporting a Fireblocks analysis)
- Greg Isenberg, [Cloudflare will make 1000+ AI millionaires](https://www.youtube.com/watch?v=MNNfat_QP0E) (August 10, 2026)
- Wikipedia, [DigiCash](https://en.wikipedia.org/wiki/DigiCash) and [CyberCash](https://en.wikipedia.org/wiki/CyberCash)
Featured photo: 183A Toll Road Park Street Mainline Toll Plaza, Cedar Park, Texas, by Larry D. Moore, [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), via [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:183A_Toll_Road_Park_Street_Mainline_Toll_Plaza_2021.jpg).
---
The old web paid for itself with attention. The agent web will pay for itself with useful resources: clean data, working tools and pages worth reading. x402 is the plumbing for that second model, and in 2026 it is still new plumbing with very little water in it. The part you can act on now does not need a wallet. Structure what you know, keep it fresh, and make it easy for an agent to use. In a workspace that is one loop: projects remember, agents think, automations execute. ▲ ■ ● [Build your first agent-ready app with Taskade Genesis →](https://www.taskade.com/create)