📅 Historical page. 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. → See current

223 Private-Address Requests in a Day

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 (private-only 172, internal 22, non-http 20, unresolvable 9) · 21 IPs · 31 endpoints · 0 service strikes
Endpoint groupRefusals
fetch one URL86
retrieve / render a page22
headless browser scrape22
reachability probe · PDF fetch · banner grab (each)9
PDF text 6 · ping 5 · url-expand 4 · preview 44–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 happenedOwnerWhat the ledger must say
URL is malformed, or points at a private/reserved addresscallerrefused / caller, HTTP 400
The resolver itself failed (timeout, EAI_AGAIN)platformfailed / platform, no strike
The target answered 500, or never answeredtarget / sellerfailed / 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.