What is x402? Internet-native payments for agents, explained

What is x402?

x402 is an open payment standard created by Coinbase in 2025. It lets an AI agent pay for something on the internet instantly, using stablecoins (digital dollars like USDC), without an account, a login, or a checkout page. Since April 2026 it lives under the Linux Foundation, with Google, Visa, Stripe, AWS, Cloudflare, and Anthropic among its backers.

The name comes from an old piece of the internet. When a web page doesn't exist, you get an "Error 404." Since the 1990s, the web has also had a code 402 that means "Payment Required." It was set aside for a future where you could pay for things directly on the web, and almost nobody ever used it. x402 finally puts it to work.

The simplest way to think about it: UCP, ACP, and AP2 help agents shop the way people shop. x402 lets agents pay the way machines work: tiny amounts, instantly, thousands of times a day.

Here's the problem it solves. Say an agent needs to read one paywalled article, pull one report from a data provider, or use a paid tool for ten seconds. Today, every one of those requires creating an account, entering a card, and often signing up for a monthly plan. A human might do that once. An agent that needs a hundred different services can't. And card payments don't work for a two-cent purchase anyway, because the fees cost more than the thing itself.

What x402 actually covers

x402 is essentially one short conversation between the agent and the website, and it happens in about the time it takes a page to load:

1. The agent asks for something: a page, a file, a piece of data, a tool.

2. The website replies "402: Payment Required," along with the price, the currency, and where to send the money. Think of it as a price tag the agent can read.

3. The agent pays from its digital wallet and asks again, this time with proof of payment attached.

4. The website checks the payment and hands over what was requested.

That's it. No account, no password, no saved card, no subscription. The website doesn't even need to know who the agent is to get paid. The same four steps work whether the price is $0.001 for a single search result or $50 for a full research report.

Because it runs on stablecoins, the payment settles in seconds and the fees are a tiny fraction of a cent, which is what makes these micro-purchases possible in the first place.

Why x402 is different from the other protocols

Every other protocol in this series starts from the world of shopping: products, carts, checkouts, cards, and a person who eventually wants a package at their door. x402 starts from the world of the internet itself. It's built for agents buying from other software, not from stores.

That changes almost everything. With UCP or ACP, the buyer is usually a person, and the agent is their assistant. With x402, the buyer is often just the agent, paying for whatever it needs to finish a task: a weather feed, a translation, a search, another agent's help. Nobody is waiting on a shipment.

It also changes how trust works. AP2 builds trust with signed records of what the person agreed to. ACP builds it with narrow, single-use payment tokens. x402 mostly skips the question: the money arrives before the goods are handed over, so the seller has already been paid by the time it delivers. That's simple and fast, but it means the protocol itself says very little about who is paying or why.

The two worlds can still meet. AP2 already has an extension that lets its signed mandates carry x402 payments, so an agent can use AP2 for permission and x402 for the money.

How a business adopts x402

The typical x402 seller isn't a retailer. It's anyone with something useful an agent might want to pay for: an API, a data feed, a news site, a research database, an AI tool.

For most of them, adoption is a small change. A few lines of code tell their server which pages or tools cost money and how much. When an agent asks for one without paying, the server sends back the price tag. Cloudflare, one of the protocol's founding partners, has built x402 into its tools for websites and agent developers, and Stripe started supporting x402 payments in early 2026. Sellers don't have to touch crypto directly if they don't want to: payment providers can handle the stablecoin side and settle in regular dollars.

On the agent side, the agent needs a digital wallet with some stablecoins in it. Coinbase and others now offer wallets designed specifically for agents.

It's still early. x402 crossed 100 million transactions by mid-2026, but most of them are very small, and the total money moving through it is modest compared to card payments. The move to the Linux Foundation, with Google, Visa, and AWS on board, is what signals that the big players expect machine-to-machine payments to matter a lot more soon.

Where Beltic fits in

x402 makes paying easy. That's exactly why someone needs to watch what's being paid for.

Think of it like a vending machine. Put the money in, get the snack, no questions asked. That works because a vending machine sells candy. Now imagine one that sells access to financial data, customer records, or the ability to send messages on someone's behalf, and anyone with a wallet can walk up and use it as many times as they want. The machine always gets paid. Nobody checks who's buying, or why.

The risk runs in two directions. On one side is the seller, who has no idea which agent just paid, who sent it, or whether it's using the service for something the seller would never allow. On the other side is the person or company whose wallet the agent is spending from. An agent can be tricked into paying the wrong website, get stuck in a loop paying for the same thing over and over, or quietly drift far away from the task it was given. Every one of those payments goes through, because a payment is all x402 checks.

That's the gap Beltic fills. Here's how it works in practice. Before an agent's x402 payment goes out, or before a seller hands over what was paid for, Beltic looks at who is behind the agent, what task it was given, and whether this payment actually fits that task. A research agent paying a few cents for a market report fits. The same agent paying hundreds of unknown websites in an hour does not. Beltic turns that into a clear risk read, and the wallet provider, the business running the agent, or the seller applies its own rules: allow it, block it, or ask a human to confirm.

For wallet providers and fintechs, the payoff is letting customers hand their agents a wallet without worrying about it being drained. For sellers, it's knowing who is on the other side of the payment.

x402 lets agents pay for anything in seconds. Beltic makes sure every one of those payments is one someone would actually approve.

This post is part of our series on agentic protocols. For how they all fit together, read What are agentic protocols? A plain-English guide.