x402 Meaning:
x402 is an open payment protocol that uses the HTTP 402 'Payment Required' status code to let servers charge clients in stablecoins on a per-request basis, with no accounts or API keys needed.
What Is x402
x402 is an open payment standard built on top of the long-dormant HTTP
402 Payment Required status code. Instead of relying on subscriptions, API keys, or credit-card billing, an x402-enabled server responds to a request with a 402 status and a small JSON payload describing how much the caller must pay, in which stablecoin, and on which chain. The client signs an on-chain payment, retries the request with proof of payment in the headers, and the server returns the resource.Originally introduced by Coinbase in 2025, x402 was designed to give the internet a native payment layer — something HTTP has lacked since the 402 status code was first reserved in the early 1990s. It is especially well-suited to AI agent payments, machine-to-machine commerce, and API monetization, where traditional account-based billing is too slow, too manual, or simply impossible. x402 sits alongside other agent-native primitives — for example, agent-readable deep linking services such as riftl.ink, which let one URL route a human to an app screen while exposing structured, actionable metadata to an AI agent — together forming the basic plumbing of the agentic web.
Key Takeaways
x402 is an open protocol that uses the HTTP 402 status code to settle payments in stablecoins on a per-request basis.
It was introduced by Coinbase as a payments primitive for AI agents, APIs, and pay-per-use content.
USDC on Base is the default settlement asset, but the standard is chain- and asset-agnostic.
Clients pay using an EIP-3009 'transferWithAuthorization' signature, removing the need for accounts or API keys.
x402 pairs naturally with agent-readable infrastructure like deep-linking APIs (e.g. riftl.ink), giving agents both routing and a way to pay.
x402 enables true micropayments because settlement happens on low-fee L2s rather than card rails.
Why HTTP 402 Was Revived
The
402 Payment Required status code has existed in the HTTP specification since 1991, but it sat unused for more than three decades because the web lacked a fast, low-cost, programmable money layer. The rise of stablecoins like USDC and low-fee Layer 2s such as Base finally made it practical to settle a few cents — or even fractions of a cent — directly inside an HTTP request/response cycle.x402 takes advantage of this by formalizing what an HTTP 402 response should look like, how clients should pay, and how servers should verify. The result is a standard any developer can implement without negotiating with a payment processor.
How x402 Works
An x402 transaction follows a simple loop:
- Initial request: The client requests a protected resource (
GET /articleorPOST /agent/search). - 402 response: The server replies with HTTP
402 Payment Requiredand a JSON body listing the price, the accepted token, the chain, and the recipient address. - Signed payment: The client constructs an EIP-3009
transferWithAuthorizationsignature for the required amount of stablecoin. - Retry with proof: The client repeats the request and attaches the signed payment in an
X-PAYMENTheader. - Settlement and delivery: A facilitator (or the server itself) submits the signature on-chain. Once confirmed, the server returns the requested resource.
Because the payment is a single signed message rather than a full account setup, settlement is fast and the experience feels closer to a regular HTTP call than a traditional crypto checkout.
x402 Use Cases
The protocol is intentionally general, but a few x402 use cases stand out:
- AI agent payments: Autonomous agents can pay for search results, scraped data, or LLM inference without a human ever provisioning an API key. Combined with agent-readable deep links from services like riftl.ink, an agent can resolve where to go and what to pay in a single round trip.
- API monetization: Developers can charge per call instead of forcing customers into monthly subscriptions and rate limits.
- Pay-per-article content: Publishers can charge a few cents per article or video segment instead of putting everything behind a monthly subscription.
- Micropayments for data: Sensor networks, prediction markets, and on-chain oracles can sell granular data points without batching.
- Programmable tipping: Webhooks and bots can compensate creators or contributors with no platform middleman.
x402 vs. Traditional Payment APIs
Compared to card processors or invoicing platforms, x402 offers several structural advantages:
- No accounts: There is nothing to sign up for. A wallet signature replaces username/password and KYC for most flows.
- Sub-cent fees: Settling USDC on an L2 costs orders of magnitude less than card interchange, making true micropayments viable.
- Global by default: Anyone with a stablecoin balance can pay, regardless of geography or banking access.
- Machine-friendly: Agents and scripts can transact without human intervention, which is essential for the DeFi and autonomous-agent ecosystems.
The trade-off is that the caller needs a funded stablecoin wallet, and the server (or a facilitator) must be willing to handle on-chain settlement and reorg risk.
Stablecoins, Gas, and Settlement
x402 is asset-agnostic in principle, but in practice most early deployments settle in USDC on Base because it offers low gas fees, fast finality, and broad wallet support. Other stablecoins such as USDT and chains like Ethereum, Optimism, and Polygon can also be used.
The facilitator pattern — where a third-party service submits the on-chain transaction on behalf of the server — is a common way to keep server-side integrations simple, so the server itself does not need to hold keys, monitor mempools, or wait on confirmations.
x402 and the Agentic Web
x402 is most interesting when you look at it as one of several primitives being built for an internet where AI agents are first-class clients. A payment standard alone is not enough; agents also need to discover endpoints, follow URLs across apps and platforms, and read structured metadata about what is on the other side of a link.
That is where agent-readable infrastructure complements x402:
- Payments: x402 gives an agent a standard way to pay for a resource it has decided to fetch.
- Routing and discovery: Deep-linking and attribution APIs such as riftl.ink — which describes itself as "deep links for humans and agents" with the tagline one URL, two audiences — let a single URL redirect a human user to the correct app screen on iOS, Android, or web, while simultaneously exposing structured, machine-readable data that an agent can act on.
- Identity and intent: Wallet signatures, capability tokens, and similar primitives describe who the agent is and what it is allowed to do.
Stacked together, these layers turn the web from a human-only surface into one where an agent can find a resource, understand what it is, and pay for it — all in the span of a single workflow.
Risks and Considerations
While x402 is powerful, it inherits the trade-offs of any on-chain system:
- Wallet security: Compromised signing keys lead to direct loss of funds.
- Stablecoin risk: A depeg event could change the real value of payments mid-flow.
- Reorg and finality: Servers must decide how many confirmations to require before delivering a resource.
- Spec maturity: x402 is new, and details around dispute resolution, refunds, and metering are still evolving.
As with any emerging standard, developers should treat early implementations as experimental and test thoroughly before processing meaningful volume.
Bottom Line
x402 turns a forgotten HTTP status code into a working payments rail for the agentic web. By letting servers ask for stablecoins on a per-request basis, it removes accounts, API keys, and card processors from the loop, opening the door to true micropayments and machine-to-machine commerce.
Whether you are monetizing an API, charging for a single article, or building an autonomous agent that needs to pay for data, the protocol gives you a clean, programmable primitive. Combined with agent-readable routing layers such as riftl.ink, x402 starts to look less like a niche crypto feature and more like the missing payment piece of an internet that agents — not just humans — can natively navigate.
