November 2026
Every claim about an x402 endpoint is conditional until somebody pays it. An
unpaid request only proves that a route can emit a payment request — it says
nothing about what arrives once the signature is attached and the USDC settles.
We argue about that gap constantly in spec threads, so this week we bought the
answer: nohumans.directory publishes a
paid-verification census, and its public statistics page puts a number on it.
Read on 16 November 2026, 19:45Z, from their own
/v1/stats and /methodology (data published under
CC-BY-4.0): 7,920 endpoints asked for payment when probed. 5,283
finished a paid delivery. That is 66.7%. The other third is not noise —
it has a shape, and the shape is useful if you publish a price.
The unpaid probe is cheap, and nearly everyone passes it
The same directory holds 10,788 active listings across 2,691 hosts. In the
last 24 hours it made 161,882 unpaid probes and 96.2% passed. Those probes ask
one question: does an unpaid request produce a payment request we can read? At
9,974 listings, the answer is yes.
That number is worth staring at, because it is the number a builder usually
quotes. "Our endpoint answers 402" is a structural claim. It is compatible with
never delivering a byte to a paying caller.
The paid table
Each endpoint gets one latest non-dry paid attempt. Across 8,002 of them:
| Outcome class | Rows | What happened |
|---|---|---|
| delivered | 5,054 | paid, body validated, settlement found on Base |
| corrected (regraded by chain evidence) | 229 | earlier rows re-read against the chain and credited |
| paid_but_status_402 | 539 | a signed payment was attached and the endpoint answered 402 anyway |
| rejected_400_blind_request | 411 | paid request rejected on input the prober could not know |
| paid_but_status_404 | 167 | paid, then the route was gone |
| declared_params_unmet | 150 | the 402 declared required parameters the call did not carry |
| stale_data / invalid_json / empty_body | 129+ | paid and served, but the body failed validation or freshness |
| price_drift | 102 | the live quote exceeded the listed price beyond tolerance |
| paid_but_status_502 | 91 | paid, upstream failed |
The directory is explicit that the pass rate is pessimistic by construction.
Its denominator is every attempt except no_payment_required — so
"refusals we chose, settlements we could not prove and our own client errors all
count against the rate". It also reports that 164 of those rows are its own
fault (payload errors, its per-call cap, unfilled templates). Take those out and
the rate moves a little, not a lot.
Three shapes worth naming
1. The endpoint that asks twice
539 rows attached a signed payment and got another 402. This is the failure
that costs a caller twice: an agent that retries on 402 will pay again. The
directory also counts a separate class for the prepayment version of it,
price_raised_at_payment — the paid request asked more than the
unpaid one quoted. Both are the same design mistake: the price is computed
again at delivery instead of being carried from the quote the caller signed. A
402 after payment is not a pricing nuance; it is the contract broken at the
moment it is executed.
2. The paid request that was never fillable
411 rows answered 400 to the paid request because the endpoint needed input
the prober could not know, and 150 more were refused before paying because the
402 itself declared required parameters the blind call did not carry. Both are
discoverability failures before they are reliability failures: the buyer could
not learn, from the 402, what to send. We fixed two of these on our own catalog
this month — a forecast endpoint whose days knob existed in the
handler and the prose but in none of the four machine-readable surfaces, and a
parameter that was advertised on one transport and missing on another. If a
field is real, it belongs in the schema, the example and the docs; if it is not
in the example, most callers will never find it.
3. The endpoint that answers from a route it cannot serve
paid_but_status_404, _405 and _502
together are 324 rows: the payment question was answered by something that
could not then serve. Our own version of this class was a route template that
got concatenated as a path segment, producing 404s on URLs we were actively
advertising — and the check that found it compares every advertised URL against
what the live door answers, rather than trusting that a listed route exists.
Our own row, and what $0.25 bought
minia2a paid this directory $0.25 to buy one of our endpoints with real USDC
and publish the result. The listing is
minia2a Weather — /x402/weather, $0.01 per call, five free trial
calls per signed wallet. What the record says now:
status verified (38/38 unpaid probes passed, score 1)
paid_verified true
paid_verified_at 2026-11-16T08:30:54Z
tx 0x96dbea55348173a96af39d138b3e53fd4bd5e3b655900ec75c1352f6779291c3
amount 0.01 USDC on Base
delivered true, schema_validated true
evidence_tier paid_verified
So the endpoint a buyer pays for is the endpoint we described, and the claim
is now someone else's chain evidence rather than ours. That was worth the quarter:
a directory that only checks structure will list an endpoint that cannot serve;
one that pays it records the truth.
Two things it did not buy.
It did not buy visibility on every query. The directory
publishes what agents ask it for, and its largest need in the 30-day window is
the bare term "weather": 311 searches, 72 client IPs once sellers' own
self-checks are excluded. For that term its own search returns us first of
three — ahead of a free listing and one at $0.001. Search a long sentence
instead, "current weather forecast for a city", and we are #14 of the 50
results we compared, behind five listings priced $0.001–$0.006. Ranking is
verified first, then relevance, probe score and purchase evidence, then price:
for a phrase, embedding relevance decides, and price breaks the near-ties among
the thousands of listings verified at a probe score of ~1. We did not cut the
price to move a line: $0.01 is what the upstream and the forecast assembly cost
us, and a race to $0.001 is not a business we want to be in. But if you are
publishing a price this month, know that in at least one directory it is a
ranking input when relevance does not separate two listings.
It did not make our MCP door verifiable. Our second listing,
https://minia2a.uk/mcp, sits at unverified,
probe_count 0, and will stay there. Not because of a bug: an unpaid
GET /mcp answers 200, an empty POST /mcp answers 400,
and the payment request lives inside a JSON-RPC error with code 402 in a
200 response — which is what the x402 MCP transport specifies. An HTTP prober
checks both verbs and looks for a 402 status; it will never see ours. The
directory has a class for exactly this (warn:payment_terms_unreadable:
"the listing does ask for payment, but an agent cannot pay it in-session"). The
practical conclusion for anyone selling MCP tools: publish at least one plain
HTTP route that answers 402, or every HTTP-based directory will record you as
not payment-gated, forever.
What we took away
A 402 is a structural claim, not a delivery claim. The only honest test of an
endpoint is a settled payment followed by a validated body — and the interesting
part is that 5,283 endpoints survive it, so the bar is not exotic. What fails
tends to fail in one of three places: the price is re-quoted after payment, the
required input was never advertised, or the route that answered is not the route
that serves.
We would rather find those with a third party's probe and our own tests than
with a buyer's first paid call.
Sources and caveats. Figures are a snapshot of
https://nohumans.directory/v1/statsand
/methodologyon 2026-11-16T19:45Z; the paid table is "each
endpoint's latest non-dry attempt", not a lifetime count, and the pass-rate
denominator deliberately includes the prober's own client errors (164 rows,
reported separately). The listing facts in the block above are that listing's
own public record. Directory data is CC-BY-4.0. Our listing URL:
/x402/weather.
Update — answering a reader comment
@felix-ilands asked the question the paid table should be able to answer: is
there a unique-payer figure per endpoint, and is it chain-derived or
seller-reported? Both halves are checkable in the published records, so here is
what they say on 17 November 2026.
The field exists, and it is not yet populated. Every listing record carries
distinct_payers. In the 25 weather listings I read, it is 0 on every one —
including rows with 800–2,724 probes and evidence_tier: paid_verified. So as
published today that column cannot separate one payer × 200 calls from 200
payers. A declared field is not a measured one.
The money evidence is chain-derived; the listing text is not. paid_verified
ships with onchain_payto_checked, observed_network (e.g. eip155:8453) and
an evidence note saying the prober paid real USDC and confirmed the settlement
on-chain. Seller-reported: URL, price, description. Probe-owned: whether a
signed payment delivered.
That split is what makes their own check land. 27,548 index calls against 27,567
chain transfers holds; 1,830 against 468 unique payers does not. A call count is
a row count; a payer count is a set, and the set has to name its source. One
more trap on top: a wallet is a key, not a customer. A buyer minting a fresh
wallet per run reads as N payers, and a velocity cap keyed on the address resets
with it.
Our own rule is the same shape. paidCalls on minia2a is wallet-level and
carries no identity; team wallets are subtracted, but a third-party verifier
that settles a real payment counts exactly like a buyer.
Originally published at minia2a.uk.
Top comments (1)
A 402 is a structural claim, agreed. So is a delivery count: 5,283 endpoints delivered says how many rows, not how many payers. One address paying 200 times reads as 200 calls and one customer.
I checked that column on the x402 discovery index against Base transfer logs. Call totals held (27,548 vs 27,567 transfers; 57,174 vs 57,156). Unique payers didn't (1,830 vs 468; 13 vs 41). Same table, one money-grade field sitting next to a junk one.
Does the census carry a unique-payer figure per endpoint, and is it chain-derived or from the seller's own report? That's the number that tells a buyer whether 10,788 listings have 10,788 customers.