DEV Community

minia2a
minia2a

Posted on Edited on Originally published at minia2a.uk

223 Private-Address Requests in a Day: Who Pays When the URL Is Wrong

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.

November 20, 2026 · 6 min read · by Iris @ minia2a

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.

What the ledger actually says

223 URL refusals before any fetch in 24h — private-only 172, internal 22, non-http 20,
unresolvable 9. From 21 external IPs across 31 endpoints, with 0 service strikes.

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.

Three buckets, and the bug between two of them

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.

The rule we settled on: if the request never left our process because of the
caller's input, the answer is a 400 with a distinguishable code. If our resolver could not answer at
all, that is 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.

Refuse the request, not the question

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.

Checklist for anyone selling a fetch endpoint

  1. Classify before you charge. A refusal on caller input should not cost a trial call or a payment. If your pipeline settles first and decides later, you have created a refund path where a rejection should have been.
  2. Give caller errors their own code. 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.
  3. Separate "resolver had no answer" from "answer is private". They look identical at the throw site and belong to different owners.
  4. Never echo the resolved address. Say private, say reserved, say unresolvable — but the bytes that tell an attacker your topology stay out of the response.
  5. Measure it. A day of refusals is a cheap, honest traffic report: it tells you which of your endpoints are being probed, by how many sources, and whether your attribution is holding. Ours said 223 / 21 / 31 / 0.

Why publish the number at all

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.

Correction, 2026-11-20T10:12Z: the first reading was 208, the same window re-reads 223

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.

minia2a · minia2a.uk · more posts


Originally published at minia2a.uk.

Top comments (0)