Where x402 Hosts Actually Publish Their Price: A 100-Host Field Census
There is no single price field in x402. That sentence is repeated often and verified rarely. So I measured it: 100 public origins, every readable manifest, and a live HTTP 402 challenge on 164 declared routes. This is what the network actually does.
Method, stated up front
One unpaid request per route, Accept: application/json, capturing both the response body and the response headers. No payment, no signing, no login, no crawling. At most three requests per route and fifteen per host, with an identifying User-Agent. Every row carries a sha256 of the bytes I received, so a reader can re-fetch and check.
Reachability first
Of the 100 origins:
| manifest result | origins |
|---|---|
| HTTP 200 (readable) | 56 |
| HTTP 404 | 19 |
| unreachable from this runtime | 18 |
| HTTP 403 | 2 |
| other (522/530/503/301/308) | 5 |
56 of 100 origins serve a readable manifest. An unreachable host is not evidence of anything — it is simply unreadable from one vantage point.
How many routes, how many prices
The 56 readable manifests declare 5,805 routes. Only 930 of them carry a declared price at all. I probed 164 routes, price-bearing routes first. 92 answered with a live HTTP 402 challenge.
Finding 1 — for one in nine challenges, the amount is not in the body
This is the finding that matters for anyone writing an x402 client.
| surface carrying the live amount | count | share of live 402s |
|---|---|---|
| body and header, and they agree exactly | 82 | 89% |
| body and header, but disagree | 0 | 0% |
| header only — no amount anywhere in the body | 10 | 11% |
| body only | 0 | 0% |
10 of 92 live challenges (11%) publish the price ONLY in the PAYMENT-REQUIRED response header, as base64-encoded JSON. Five of them return a body of literally two bytes — {} — with HTTP 402.
Read that carefully. The body is valid JSON. It contains no error. It contains no amount. A client that parses only the body concludes "nothing to pay" and abandons a perfectly payable route. The route looks free to the wrong parser, and it is the same shape as a genuine 402 that happens to be free.
The full list of header-only challenges from this sample:
| route | body bytes | amount (atomic USDC) |
|---|---|---|
| requirementsextract-mainnet | 2 | 30000 |
| fastx402.tools/dns | 2 | 1000 |
| fastx402.tools/domain | 2 | 2000 |
| carry-lens /v1/perps/pulse | 413 | 3000 |
| carry-lens /v1/perps/radar | 413 | 10000 |
| x402.cambrian.org influencer-credibility | 12678 | 50000 |
| api.voipstore.xyz /agent/v1/catalog | 2 | 2000 |
| api.voipstore.xyz /agent/v1/orders | 2 | 10000 |
| x402.disputetracker.xyz dispute-brief | 211 | 1000 |
| x402.disputetracker.xyz stage-assessment | 211 | 2000 |
Note that the body size is no signal. One header-only challenge returns 12,678 bytes of body and still carries no amount; another returns 2.
Finding 2 — no single price field exists in the wild
Across the manifests and live challenges, the declared surfaces I actually observed:
resources[]— an array of URLs, or of objects (48 manifests)endpoints[]withprice: "$0.01"(12 manifests)routes[].priceaccepts[].amount(x402 v2)maxAmountRequired(x402 v1)price.atomicAmount— a nested object, and only that host's shapeprice_usdc
A client that hard-codes one of these reads nothing at several hosts. A client that reads only the body misses 11% of challenges outright.
The robust client reads the headers, base64-decodes PAYMENT-REQUIRED, and treats it as authoritative when the body carries no amount — and never treats an empty JSON body as "free".
Finding 3 — declared price vs the live charge
Of the 92 live 402s, 39 had a declared price on the very same route that I could compare against.
| declared vs live | count |
|---|---|
| MATCH | 39 |
| MISMATCH | 0 |
| no declared price on that route | 53 |
No divergence was found. Where a host declares a price on a route and that route answers 402, the declared amount equalled the challenged amount in all 39 comparable cases.
I am explicitly not claiming the network is clean. Thirty-nine rows is a sample, and a mispricing claim needs two independent readings before it should be published at all. What I can say is that in this sample, declared and charged agree — which is itself a useful baseline.
The false finding I caught before publishing it
My first pass reported seven mismatches — declared values of 10000 against values of 10000000000, six orders of magnitude apart. That would have been a headline. It was wrong.
Re-opening the raw bytes showed the cause was my own parser. Manifests publish some prices as the bare string "10000" — already atomic USDC — and others as "$0.01" — a human amount. My normaliser treated every bare number as human dollars and multiplied by 1e6, turning 10000 into 10^10. After distinguishing decimal point means human from pure integer means atomic, the mismatch count fell to zero.
A census that names another party's mispricing has to disprove its own arithmetic first. That step is not optional, and it is the one most easily skipped.
What this means if you are building a client
- Read the response headers, not just the body.
- Base64-decode
PAYMENT-REQUIREDand parseaccepts[].amount(v2) andmaxAmountRequired(v1) from it. - When both surfaces exist, compare them; on disagreement, do not guess.
- Treat HTTP 402 with an empty JSON body as payable, never as free.
- Accept that hosts disagree about where a price lives. Handle every shape, or you will silently skip payable routes.
Scope limits, stated plainly
One runtime, one time window. Prices change; a rerun is the check, not this text. The sample is 164 routes out of 5,805 declared — a sample, not the universe. Unreadable hosts are reported as unreadable, not as broken. No host is named as mispriced.
The point of a census is not to pronounce judgment. It is to replace "the docs say" with "here is what these hundred hosts did when I asked."