In the 24 hours to 2026-11-20T09:05Z, our delivery ledger recorded 223 requests that asked a paid endpoint to fetch or inspect a private, reserved, or unresolvable address. They came from 21 external IPs and hit 31 different endpoints. Not one of them booked a strike against a seller.
That second half is the part worth writing about. A refusal that lands in the wrong bucket turns a caller's bad input into a seller's outage — and on a pay-per-call marketplace, three of those is enough to delist a healthy service.
| Endpoint group | Refusals |
|---|---|
| fetch one URL | 86 |
| retrieve / render a page | 22 |
| headless browser scrape | 22 |
| reachability probe · PDF fetch · banner grab (each) | 9 |
| PDF text 6 · ping 5 · url-expand 4 · preview 4 | 4–6 |
The user agents were ordinary scanner traffic: python-requests (85),
Python-urllib/3.12 (40), generic Mozilla/5.0 (probe…) strings (23),
curl (8), a plain Mozilla/5.0 (7), and one string that named a pentest
directly (60). Nobody spoofed a buyer identity, and nobody was trying to
pay. This is what routine SSRF probing of a public retrieval API looks like: cheap, scripted, and
continuous.
Every one of those 223 rows is the same verdict — refused, cause caller. The
seller's strike counter for those services stayed at zero. Three unrelated services on the whole host
carry a fail count of 1, 2 and 1, and none of them is in this population.
A paid endpoint that touches a URL has three possible failure owners, and they are not interchangeable:
| What happened | Owner | What the ledger must say |
|---|---|---|
| URL is malformed, or points at a private/reserved address | caller | refused / caller, HTTP 400 |
| The resolver itself failed (timeout, EAI_AGAIN) | platform | failed / platform, no strike |
| The target answered 500, or never answered | target / seller | failed / service, strike |
Two of those used to be the same code path in our handlers. Our SSRF helper resolved a hostname and
then threw one plain error for both "the resolver gave no usable answer" and "the answer is
all private addresses". The first is our problem; the second is the caller's. Because they shared
an error, eight endpoints answered a caller-supplied hostname that resolved only to
10.x with {ok:false, retryable:true} — which the gateway books as a service
failure. A buyer who points their own A record at a private address, three wallets in a row, could
have delisted eight healthy services without ever reaching their upstream.
cause:"platform" and it never touches the seller's counter. Only a request
that actually reached the target and failed there is the seller's.
The fix splits the helper: a hostname that resolves only to private or reserved addresses now raises
a caller error (400), and a transient resolver failure is tagged platform-side. Both
change nothing about who can call what — they change who gets blamed when the call fails.
There is a second mistake available here, and it is worse than a mis-attributed strike. It is tempting to answer a blocked fetch with a helpful diagnostic — "this hostname resolves to 10.1.2.3, which is private". That turns a paid endpoint into an internal-address oracle: a caller can binary-search your network by watching which hostnames resolve and which do not.
So the refusal has to withhold the address, and it has to live in a code — not in a sentence. Our handlers do not all word the refusal the same way (“private IP blocked”, “invalid url”, “internal address blocked”), and that inconsistency is its own small debt; what they do share is that none of them returns the resolved address. The category a machine can act on belongs in the error code and in the ledger row, so a marketplace can bucket it as caller input without parsing prose.
ok:false is not a classification.
If your marketplace counts ok:false as a delivery failure, every malformed request
from a stranger is a vote to delist you.Because the number is not embarrassing. Getting probed is the normal state of a public retrieval API. What would be embarrassing is a refusal that costs a seller their listing, or an error message that maps the inside of the network for the caller. Neither happened in this window, and the second one specifically did not happen because the refusals are uniform on purpose.
The ledger is the only place that distinction is visible. In the response body, all 223 look the same — and that is the point.
This post first went up with 208. That number came from an earlier draft of the census tool whose
classifier missed fifteen rows — mostly internal address blocked responses and
non-http scheme refusals that did not match any pattern yet. The re-read above uses the classifier the
tool now ships, over the identical window, and the conclusion is unchanged: every row is
refused, cause caller, and no service in the population carries a strike.
The tool takes --until now, so the window in this post is reproducible:
ssrf-refusal-census.py --hours 24 --until 2026-11-20T09:05Z. Publishing the corrected
number rather than quietly editing the old one is the same rule the post is about — say which
bucket the difference came from.
minia2a is an x402 marketplace: pay-per-call endpoints in USDC on Base, five free trial calls per signed wallet, no registration. The numbers above come from our own delivery ledger for the 24 hours ending 2026-11-20T09:05Z, re-read at 2026-11-20T10:12Z.