For nearly thirty years, the HTTP specification has included a status code called 402 Payment Required. It sat there unused — a placeholder for a future the web never quite got around to building. Browsers recognised it. Server frameworks implemented it. Nobody shipped anything on top of it, because the obvious use case — charging a few cents for a single web request — never had a workable payment rail. Credit card processing has fixed costs that make sub-dollar charges impractical, and nobody wanted to create an account just to read one article or call one API endpoint.
x402 is what finally fills that gap. It's an open protocol, originally published by Coinbase in May 2025, that uses the 402 status code to let a server ask for payment and a client pay it, automatically, within the same HTTP exchange — settled in stablecoins on a blockchain.
Strip away the cryptography and the protocol is simple. A client requests something. If it's free, the server just returns it. If it costs money, the server replies with a 402 status and a small set of payment terms: how much, in what token, on what network, and where to send it. The client — which might be a person's browser extension, but is increasingly a piece of software or an AI agent — signs a payment for that exact amount and resends the request with the payment attached. The server (or a third-party "facilitator" service) verifies the payment landed, then returns the actual content with a normal 200 OK.
The entire loop typically completes in a few seconds. There's no account creation, no stored card, no invoice, and once the payment settles on-chain, there's no chargeback or dispute process — it's final.
Two things had to happen before this was viable. First, transaction costs on certain blockchains had to fall low enough that paying a fraction of a cent didn't itself cost more than the payment. Layer-2 networks like Base brought typical fees down to roughly a cent or less, which made the economics work for the first time.
Second, stablecoins needed to mature into something genuinely boring and reliable — a digital dollar that doesn't introduce currency risk into a transaction. USDC, pegged to the US dollar, became the default settlement asset for x402 largely because it's well understood, widely supported, and doesn't ask either party to take a view on crypto price movements just to use an API.
The clearest use case so far is machine-to-machine payment — specifically, AI agents paying for things autonomously. An agent that needs a data feed, a translation API, or a few seconds of compute can't fill in a credit card form or wait for a human to approve an invoice. x402 gives it a mechanical way to pay per request without any human in the loop.
That idea has attracted a wide set of backers. The protocol is now governed by the x402 Foundation, with members spanning Google, Visa, Stripe, AWS, Mastercard, and Circle (the issuer of USDC), alongside infrastructure players like Cloudflare, who co-founded the foundation with Coinbase. Google's own Agent Payments Protocol (AP2) uses x402 as one of its settlement rails, and Stripe has built its own agent commerce tooling that connects to it as well. That's a genuinely broad coalition for an eighteen-month-old protocol — it suggests this isn't one company's side project, but an emerging shared standard.
It's worth being clear-eyed about scale. x402 is not yet competing with the volume of traditional payment processors — total annualised volume through the protocol is a small fraction of what a single major processor handles in a day. It's also not a replacement for subscriptions or e-commerce checkout; nobody is suggesting you buy a sofa over x402. It solves a narrower problem: tiny, frequent, often machine-initiated payments that traditional rails were never built to handle economically.
If you run an API, a content site, or any service that AI agents might want to call programmatically, x402 is worth understanding now rather than later — adoption is accelerating, and the tooling to accept it is becoming easier by the month. If you're simply curious, the protocol is a useful lens on where machine-driven commerce on the internet seems to be heading: toward payment as a normal, automatic part of a request, rather than a separate human-mediated step.
This page is for general information and isn't financial or technical advice. Protocol details change — check the current x402 specification before building anything that handles real payments.