Why I'm Passionate About x402

I've been building on the web for a long time, and I've paid a lot of middlemen along the way: payment processors, billing platforms, marketplaces, subscription tools. Each one added an account, a fee, and another step between a buyer and the thing they wanted.

x402 is the first payment standard in years that made me think that stack could get a lot thinner. This post explains why I care about it, what we're doing with it at _done, and where it isn't ready yet.

x402 in one minute

HTTP has had a status code called 402 Payment Required since the 1990s. It was "reserved for future use" and almost nobody used it. x402 is an open protocol, started by Coinbase and backed by Cloudflare among others, that finally puts it to work.

The flow is simple:

1. A client requests a resource.
2. The server answers 402 with a price and where to pay.
3. The client pays, usually in USDC on Base or Solana, and retries with proof of payment.
4. The server checks the payment (typically through a facilitator such as Coinbase's) and returns the result.

There's no signup and no key. Paying is how you authenticate.

Why I'm excited about it

The potential is huge. Almost every online interaction that involves money can be expressed as "request, price, pay, deliver." That covers APIs, data, content, files, and eventually ordinary checkouts. A native payment layer for HTTP is a big idea, not a niche one.

No accounts, no logins, no API keys. Think about what a developer goes through to try a new API today: sign up, verify an email, find the dashboard, create a key, store it somewhere safe, add a card, pick a plan. With x402, all of that collapses into one retried request. There are no keys to leak and no passwords to reset.

It's built for AI agents. An agent can't click an email confirmation link or fill in a billing form, and it shouldn't have to. Give it a wallet with a few dollars and it can buy exactly what it needs to finish a task, one call at a time.

Fewer middlemen, lower fees. Card payments carry fixed fees that make anything under roughly 30–40 cents uneconomical. With x402, charging a cent or less per call actually works. The money moves from buyer to seller without a stack of platforms each taking a cut. That makes pricing models possible that simply didn't exist before.

What we're experimenting with at _done

_done is a catalog of small, pay-per-call utility APIs aimed at AI agents: things like DNS and WHOIS lookups, screenshots, OCR, hashing, QR codes, and SEO extraction. Every call costs one cent in USDC over x402. There's no account and no key.

We picked these tools deliberately. They're tasks an LLM genuinely can't do on its own. A model can't resolve DNS, reach a live website, or compute a correct SHA-256 hash, however confident its output looks. An agent that can pay a cent to get the real answer is more useful than one that guesses.

What we're learning along the way:

• Discovery matters as much as payment. Each API publishes an openapi.json, and we list on registries like x402scan and the Coinbase Bazaar. An agent can't pay for a tool it can't find.
• Machine-readable descriptions need care. Agents read your spec literally. A sloppy description gets a wrong call, and the buyer still pays.
• One cent is the norm. Agents expect tiny payments, and a flat price keeps things predictable.

The honest downsides

I'm excited about x402, but it's early, and pretending otherwise wouldn't help anyone.

• Buyers are scarce. Most people don't have a crypto wallet, and most agents aren't set up to pay yet. Right now there are more services accepting x402 than clients using it.
• The spec is still moving. Implementations differ slightly, and what works today may need changes in a few months.
• "Crypto" is a hard sell for some. Even with a dollar-pegged stablecoin, some buyers and finance teams will say no on principle.
• Don't expect overnight revenue. Adding a 402 to your API won't bring in money by itself. Demand is still catching up.

Should you care?

If you're building tools for AI agents, I'd start experimenting now. Nobody else has solved "an agent buys something without a human" this cleanly.

If your customers are mostly people with credit cards, add x402 alongside your existing checkout, not in place of it. It's cheap to set up, and you'll be ready as demand grows.

I'll keep sharing what we learn from running _done. If you're building with x402 too, I'd like to compare notes in the comments.