An agent can write code, plan a trip, and reason about your calendar. What it cannot do is create an account, verify an email, and paste an API key into a dashboard. Which means almost every useful tool on the web is locked behind a door only humans can open.
That door is coming off its hinges. A new class of API answers a cold request with a price instead of a login page, using an HTTP status code that sat reserved and unused for almost thirty years: 402, Payment Required. An agent reads the price, attaches a payment, retries, and gets the result. Two requests. No account. No key. No human.
Today Ora indexes this new surface of the web: 23,000 payable capabilities across 1,216 hosts, every one normalized and graded. Most of that catalog is junk, and the grading is the point: 5,404 entries earn the servable tier, and those are what agents see. The servable set appears in the directory next to the products we already rank, and agents can search it directly through Ora’s MCP server. It is the index of what agents can hire, not just what they can read - an index of the paid web that grades instead of mirrors: re-walked and re-graded daily, with an unpaid probe pass working through the servable set in daily batches, built for agents rather than people.
The API key was built for people
Every integration on today’s web assumes a person is in the loop. Someone finds the API, signs up, confirms an inbox, enters a card, generates a key, and stores the secret. Only then does the first request happen. Agents fail at step two, and so the standard answer has been to pre-wire everything: a human collects the keys in advance and the agent uses whatever it was handed.
That works until the task needs a tool nobody predicted. An agent researching flight prices at 2am cannot wait for you to wake up and sign up for an aviation data API. The pre-wired model caps what agents can do at what their operators anticipated.
the API-key way
- 1find the API in a search engine
- 2create an account
- 3verify an email inbox
- 4add a credit card
- 5generate an API key
- 6store the secret somewhere safe
- 7read the docs, write the call
the 402 way
- 1ask the index for a capability
- 2call it, read the price in the 402
- 3retry with payment attached
The alternative arrived quietly through open standards. Coinbase published x402, which repurposes the 402 status code for machine payments in stablecoins. Stripe co-authored the compatible Machine Payments Protocol on the same foundation. Under both, the API quotes its price in the refusal itself, and payment rides in a header on the retry. Metering replaces membership. The whole onboarding is one round trip.
GET /forecast?city=berlin HTTP/1.1
host: api.weather.example
402 Payment Required
price: $0.001 USDC
payTo: 0x4b8f...9c2e
GET /forecast?city=berlin HTTP/1.1
x-payment: <signed $0.001 authorization>
200 OK
{ "city": "berlin", "high": 24, "rain": 0.1 }
Look at what is absent from that exchange. No OAuth dance, no terms-of-service checkbox, no key rotation policy. The price is a tenth of a cent, which no card network could clear profitably and no subscription would bother metering. This is the granularity agents actually want: pay for one forecast, one search, one lookup, exactly when the task needs it.
An open registry has an honesty problem
These payable endpoints announce themselves in an open registry that anyone can list into, no review, no gatekeeper. That openness is the point, and it is also the problem. When we walked the full registry, one flooding host accounted for 10,028 of the 23,000 entries, 44% of the entire catalog by itself. Another 10,197 entries carry no usable description at all: an agent reading the listing cannot tell what the tool does. There are testnet toys priced in fake money and identical listings pasted dozens of times.
Counting to 23,000 is easy. Knowing which of the 23,000 will answer, do what the listing claims, and charge what the listing says: that is the actual work, and it is the work we built Ora to do. So we index everything and grade everything. Every entry gets a trust tier and keeps it, with the reason attached. Agents are handed the servable tier by default; the rest stays indexed, so the moment a host cleans up its act, the next crawl upgrades it.
indexed
every payable endpoint in the registry
one flooding host
a single domain, repeated 10,028 times
no real description
an agent cannot tell what these do
testnet / mispriced / dupes
fake money, $100 pings, copy-paste listings
servable to agents
described, priced in real dollars, not spam
This is the same posture our scan takes toward the rest of the web. We do not mirror claims, we verify them. A directory that republishes an open registry unfiltered is not a discovery layer, it is a louder copy of the spam.
The refusal is a free lie detector
The protocol has a property that makes verification almost elegant: you can audit an endpoint without paying it. Send an unpaid request, and a healthy endpoint returns its 402 challenge, which contains its live price, its accepted payment methods, and proof that someone is home. The refusal is the audit.
Every unpaid request returns the endpoint’s live price, for free. We turned the payment protocol’s own handshake into the verification layer.
Ora re-crawls the registry daily and probes the servable set in daily batches, rotating through the whole tier on a schedule of weeks, never re-probing the same rows while others starve. The first probe batches were clarifying: some endpoints were already gone, returning 404s to a registry that still advertises them, and more than half answered with something other than a clean payment challenge. When a live price drifts from the listed one, we record the live one. When an endpoint dies, it silently drops out of what agents see. A listing in the registry is a claim; a fresh 402 challenge is evidence.
What this unlocks for agents
Go back to the agent researching flights at 2am. This is where its night used to end: the travel data API wants an account, and you are asleep. Connected to Ora’s MCP server, it instead calls search_capabilities with plain language: “flight search by route and date.” The index answers with priced endpoints, probe-verified ones ranked first - travel searches for a cent or two, sitting alongside forecasts for a tenth of a cent and web searches for three. The agent picks one, reads the price in the 402, pays from its own runtime, and keeps working. By the time you wake up, the itinerary is built and the tooling bill for the whole detour is a few cents. Ora is not in the payment path and takes no cut. We are the index that told the agent the tool exists, works, and costs what it says.
The other half of this story belongs to the people who build tools. A payable endpoint in the index has a property no traditional API business has ever had: its customers can be software. There is no funnel to optimize and no sales call to book. Publish an endpoint, describe it plainly, price it honestly, and keep it alive - and every agent connected to the index becomes a potential caller. Those requirements are not arbitrary; they are exactly what our grading checks. The registry is open to anyone. The servable tier is earned.
For the humans, the same index lives in the directory behind a “Paid capability” filter, alongside the scored products and MCP servers already there. One search surface, everything an agent can reach.
Ora exists to answer one question: how agents choose who to work with. We have argued since the first scan that agents are already transacting with businesses that built for them and failing silently with the ones that didn’t. Until now, “built for them” meant publishing the right files and structuring the right pages. The capability index extends the answer to the transaction itself: tools an agent can discover, evaluate, and hire in seconds, with no human in the loop. The catalog is 23,000 deep today, re-graded every day, and only the 5,404 entries that earn the servable tier reach agents, because an index you cannot trust is just a longer list.
Browse it at /directory, or point your agent at Ora’s MCP server and let it ask for itself.