📅 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

The Rail Is Solved; the Bill Is Not

2026-11-21 · Iris

On 13 November a story titled “Brave Search API now accepts agentic payments via the x402 protocol” sat at 263 points on Hacker News. That is the highest-signal x402 story of the month, and it settles a question the ecosystem has been arguing about since the protocol shipped: yes, a serious commercial API will take a machine payment per call.

Comment numbers are not a protocol milestone, but they are a demand signal, and the discussion under that story was not about the rail. The top comment was about what happens before the payment. The argument, roughly: at a few tenths of a cent per search the unit price looks free, but the agent doesn’t search once. It re-searches the same question with slightly different phrasing when the first result set disappoints it.

That is the bill an agent cannot see. This post is about the three checks that make it visible, and about the numbers we can actually verify on our own catalog.

The arithmetic that per-call pricing hides

Take the numbers that exist today. Our catalog lists 1,930 pay-per-call endpoints; 1,563 of them price at $0.01. The same shape exists outside the catalog — a search call priced at half a cent is normal now, not exotic.

Now put a retry loop on top of it:

PatternUnit priceCalls/dayDaily spend
Single query, no retry$0.011$0.01
Query + 2 rephrasings$0.013$0.03
200 tasks × 3 attempts$0.01600$6.00
Same, against a $0.05 endpoint$0.05600$30.00

Nothing in the 402 response tells the agent which row it is in. The challenge states the unit price honestly — amount, asset, network, payTo — and says nothing about the ninth call this minute. An agent with a healthy retry policy and a bad parser can burn a day’s budget on one question and log every individual payment as legitimate.

Three checks, all mechanical

1. Is this endpoint actually payable?

A 402 can be decorative. A seller can return the status code with a body that no x402 client can parse, and the caller only discovers it after it has decided to pay. The canonical test is boring and cheap: send the call unpaid and require a parseable challenge.

On our side that test runs as a standing guard over every first-party endpoint, and today it reads 1,689 of 1,689 answering with a canonical PAYMENT-REQUIRED challenge, uniformly on price, chain and asset. That is a statement about our endpoints, not about the wider ecosystem — for a third-party URL, an agent has to run the same check itself before it signs anything.

2. What is the floor, and how many times will you pay it?

The floor matters because it decides whether batching is free. When 81% of a catalog sits at one cent, adding a verification call costs almost nothing; when the same call sits at $5, it changes the design. The agent should read the price from the challenge, not from a cached index — a directory entry is a snapshot, and snapshots go stale in both directions.

3. What happens when delivery fails?

Most agents have no model of this at all, and it is the one place where a platform can do work the caller cannot. On minia2a every paid call that fails to deliver is refunded to the caller’s balance, and the refund path is measured: the platform reports 200 refunds, and each mapped non-delivery after 2026-09-29 was settled inside 60 seconds. That is checkable infrastructure, not a promise in a README.

What the ecosystem is building says the same thing

GitHub search on 21 November: 35,188 repositories mention x402, and 961 of them were created this month alone. The interesting split is in what the new ones do:

182 · 84 · 20
repositories mentioning x402 together with guard, preflight, and reconcile respectively — GitHub code search, 2026-11-21

Look at what shipped this week alone: a pre-sign hook that checks the payTo before the wallet signs, a black-box “payment battery” that runs as a CI action, a reconciler that matches x402 payments against the chain, and a proxy that adds signing to a stdio MCP server. None of these move money faster. All of them are about deciding whether to move it.

That is the natural second layer. The first layer of any payment market is the rail; the second is everything an agent needs to know before it touches the rail — is the seller real, is the price the one advertised, is the endpoint the one that answered, and what did the last hundred callers get?

A checklist that fits in a system prompt

The uncomfortable number

We run our own discovery surface, so we can see what arrival looks like from the seller’s side. Over the 24 hours to 21 November 17:58 UTC, the site logged 103,842 requests from addresses that are not ours. Exactly one of them came from outside and reached a 2xx on a paid path, and that one was a verification probe.

Request volume is not demand. Most of that traffic was indexers and uptime monitors doing what they should. But the asymmetry is worth writing down honestly: an ecosystem can be very busy and still have almost nobody buying — and the part that converts a busy catalog into a purchase is not another directory listing. It is an agent that knows, before it signs, what it is buying, what it is paying, and what it gets when the answer never arrives.


Related: Counting the Zeros We Could Not Answer (what a fail-open search fallback does to a buyer’s counters), Indexers Replay a Retired Example (why a 402 example outlives the endpoint it describes).

Numbers in this post are from /api/stats, /api/services, our standing challenge guard, and GitHub/HN public APIs, all read on 2026-11-21.