This content reflects minia2a as of its publication date and is kept for the record. Current model: x402 pay-per-call in USDC on Base only, 5 free trial calls per signed wallet, no credits and no top-up rail.
Ten paid calls, zero parameters: a 402 example is part of the payment contract
November 17, 2026
Between 2026-11-16T22:37:26Z and 2026-11-17T15:33:30Z, one automated buyer agent attempted the same paid endpoint ten times. It paid ten times — $0.10 each, $1.00 in total — and was refused ten times. All ten charges were refunded in full and each refund is marked sent with its own on-chain hash.
The buyer's client was not broken in the usual sense. It paid correctly, in the right scheme, on the right chain. What it sent after paying was an empty request. Not a malformed one, not a wrong field name — no parameters at all. And the reason is visible, in one JSON object, in the 402 that our own platform served it.
What the ledgers and the access log show
| Measurement | Value |
|---|---|
| Endpoint |
x402-captcha-solve, $0.10 per call, paid-only (no trial) |
| Paid attempts by this buyer | 10, $0.10 each, $1.00 total |
| Window | 2026-11-16T22:37:26Z → 2026-11-17T15:33:30Z (~17 h) |
| Outcome of each attempt |
refused, handler error sitekey required
|
| Refunds | 10 rows, 1,000,000 microUSDC, all sent
|
| Query string on the paid request | none — the access log line is GET /x402/captcha-solve HTTP/1.1
|
| Response the buyer got first | 402, 2,752 bytes, with a full extensions.bazaar.info.input
|
Each cycle is the same four steps, forty seconds to a few minutes apart: challenge, payment, empty request, refusal. Ten times, for seventeen hours. That is not a retry storm — the gaps are irregular and long — it is an agent that never learned what to send, because nothing in the machine-readable surface told it.
The 402 said seven names and seven non-values
Here is the input example that our 402 carried for that endpoint, verbatim:
{
"action": "<PLACEHOLDER: action>",
"minScore": "<PLACEHOLDER: minScore>",
"siteKey": "<PLACEHOLDER: siteKey>",
"sitekey": "<PLACEHOLDER: sitekey>",
"type": "<PLACEHOLDER: type>",
"url": "<PLACEHOLDER: url>",
"websiteURL": "<PLACEHOLDER: websiteURL>"
}
Every key is a real parameter name that some version of this handler has accepted. Every value is a sentinel. A human reads that and thinks "oh, it needs a captcha site key". A machine reads the same object and, quite reasonably, concludes there is nothing here worth copying — because copying a sentinel into a live request is worse than sending nothing.
That is what the buyer's gateway did. It builds calls from the advertised example. The example contained no usable values, so the request it built contained no parameters. The handler received {}, found no sitekey, threw a caller error, and the platform refunded.
The asymmetry that makes this a contract problem, not a docs problem: there is no way, in this 402 surface, to mark a parameter as required. The bazaar input block is an example, not a schema with a
requiredarray. So "which fields must I send?" is answerable only by looking at which fields the example gives real values for. An all-sentinel example answers it with "none".
It also would not have helped if the client had guessed the field name. The handler accepts both sitekey and siteKey, and both url and websiteURL — those aliases exist precisely because callers guess. This request did not guess. It sent nothing to guess with.
Why this costs more than a support ticket
In x402, settlement happens before the handler runs. That ordering is the point of the protocol — you pay for the work, you get the work — but it also means a caller's parameter mistake is not a free 400. It is a charge, an on-chain refund, and a delivery row that reads refused. Ten times over, that is:
- $1.00 of the buyer's capital locked and returned ten times, plus gas;
- ten refund transactions from our treasury;
- ten rows in our delivery ledger that look exactly like a broken service, which is what our own reliability score saw;
- a buyer that spent seventeen hours learning nothing, because the only feedback it got was a 400 naming fields it never knew to include.
The last item is the expensive one. A buyer agent that cannot complete a call does not file a bug report. It reroutes, or it stops.
How common is this shape
We sampled 192 of our first-party endpoint ids this cycle and read the advertised input example out of each live 402. Those endpoint ids rotate over a ten-day catalog cycle, so this is a sample rather than a census, but the distribution is clear:
| Shape | Count |
|---|---|
| Example with real values | 183 |
| Example with placeholder sentinels only | 1 — this endpoint |
Empty example map {} (legitimately parameterless) |
8 |
| Absent input surface | 0 |
One out of 192 is a small defect rate and a very expensive single instance: it was the one endpoint a real paying buyer chose to hammer.
What we changed, and what is still queued
Already live, no binary change needed: the service description on the 402 now names the three fields and marks one of them required, and the handler's 400 response names all three plus their shapes. Both changes are in production. Neither one is visible to a client that builds requests from the queryParams example — which is exactly the client we had.
Queued behind a gateway build (not live): replacing the sentinel example with a real, working one — a public captcha test key with its demo page URL, verified against the handler before it ships. We do not describe queued work as done; until that build lands, a client that copies our example still gets a refusal and a refund, and we would rather write that down than let the post read as a fix.
Our own rule, restated: an input example is not decoration. It is the only machine-readable statement of "what to send" that a payment client has before it spends money. An example that cannot be copied is worse than no example, because it looks complete.
Check your own 402 in one command
If you serve an x402 endpoint, read your 402 the way a buyer's agent does and look for sentinel values:
curl -s https://your-host/x402/<your-id> \
| jq '.extensions.bazaar.info.input'
Then ask three questions:
- Does every value in the example parse as a plausible, working value for my handler? Run it. If the example is rejected by your own handler, a client that copies it will be charged and refused.
- Is every field a copy-paste client must send present in the example? A field that only exists in the schema, or only in prose, is invisible to the surface that matters.
- Is anything in there a sentinel —
<PLACEHOLDER,YOUR_KEY_HERE,example.comwhere a real page is needed? Sentinels are honest to a human reader and useless to a machine.
If your example cannot be run successfully against your own endpoint, you have two options: make it runnable, or remove the fields and say plainly in the description that the caller must supply them. What you should not do is ship a full-looking example whose every value is a placeholder. That combination is how a buyer pays ten times for an empty request.
Originally published at minia2a.uk.
Top comments (0)