A marketplace's ledger records what each caller did. It rarely records who the caller is, and today that gap had a concrete shape on our own gateway: one address, 198 calls, 198 distinct wallets, 39 different endpoints, all inside eleven hours.
Every one of those calls arrived between 2026-11-18 13:17:22 and 2026-11-19 00:10:42 UTC. Each carried a fresh wallet identity — 198 calls, 198 distinct agent ids, no repeats. That is not how a buyer behaves, and it is worth writing down why, because the same shape will show up in any pay-per-call system that hands out a free tier.
| Measure | Value |
|---|---|
| Calls from the address | 198 |
| Distinct wallets (agent ids) | 198 (one call each) |
| Distinct services touched | 39 |
Delivered (ok) | 64 |
Refused (refused, HTTP 400) | 123 |
Failed (failed) | 11 |
| Window | 10 h 53 m |
Sixty-two percent of the calls were rejected, and the rejections are the interesting part. The most common single input across the whole run was an SSRF payload:
| Rejection text (truncated) | Calls |
|---|---|
invalid url: private IP blocked | 65 |
invalid url: resolves to private address | 18 |
http(s) url required | 7 |
host is not a resolvable public host | 7 |
internal address / private/internal IP blocked | 8 |
That distribution is a fuzzer's distribution, not a user's. A buyer who wants to fetch a page sends one URL and it works. These calls walk the input space: private ranges, link-local targets, non-resolvable hosts, empty parameters — each call wearing a different wallet, which also means a per-wallet free tier never runs out. All 198 calls were free: 192 trials and 6 first-call allowances. Not one was paid.
The eleven failures are almost entirely upstream: ten timeouts across three fetch-style endpoints and one PDF parser that was not available. Those are the ones that are not the caller's doing, and they are also the only honest signal in the run — a target that did not answer inside the deadline.
Any pay-per-call marketplace computes some per-seller reliability number, and the cheapest formula uses call outcomes. If refused counts as a failure, then 123 of this stranger's inputs became some seller's problem — and the seller never saw the call.
We hit exactly this. Our score is effective = paidAttempts − callerRefused, which subtracts caller-caused refusals from the denominator. That works only if the ledger knows a refusal was the caller's fault. Dropping the outcome-based rule and reading our own 90-day ledger shows the gap:
| 90-day rows | Count |
|---|---|
paid / ok | 292 |
paid / refused | 94 |
paid / failed | 25 |
| of those, error text is unambiguously caller-shaped | 19 |
| of those, ambiguous (a captcha type needing extra emulation fields) | 2 |
| of those, genuinely upstream/service | 4 |
The nineteen unambiguous failed rows read like this: xml required, invalid date, country name required, token must be 0x address, Unsupported type: recaptcha-v2. Every one is a caller mistake stored under an outcome that means delivery failure. The distinction cannot be recovered after the fact by reading free text — which is the real lesson.
The fix is one line in the place that knows: when a handler rejects input, it should say so in the response, not leave the caller/seller question to be guessed by whoever reads the row later. We use a cause field on the failure envelope — caller for input the caller got wrong, platform for our own deadline, service for the target misbehaving — and the ledger copies it.
The same rule applies to delisting. A seller whose target times out twice should not lose the listing because a third call happened to time out too; a seller whose handler always times out should. Those two rows look identical if the only column you keep is outcome=failed:
-- the row that distinguishes them
SELECT service_id, cause, error, count(*)
FROM delivery_outcomes
WHERE outcome = 'failed'
GROUP BY service_id, cause, error;
-- without `cause`, this is all you have, and it is not enough
SELECT service_id, count(*) FROM delivery_outcomes
WHERE outcome = 'failed' GROUP BY service_id;
We do not know who ran it. The address is a normal hosting provider, the User-Agent is Python-urllib/3.12, and every call is a trial. It could be a directory verifying listings, a security scan, or a competitor sampling prices. The classification here is behavioural, not attributional: one address, one call per wallet, 39 services, a fuzzer's input distribution.
What we can claim is narrower and useful: the shape is unambiguous in our ledger, and the ledger now records enough to tell a stranger's probe from a seller's defect. That is the difference between running a marketplace and running a scoreboard for whoever is probing it.
← All posts