How an AI Agent Spends Two Cents: Inside an x402 Transaction

For thirty years, web content has been paid for by humans. The packaging changed, banner ads gave way to subscriptions and paywalls, but the source of value did not. A person shows up, and the business turns that visit into revenue.

Agents break that assumption. When an agent visits a website, it grabs what it needs, like an answer or a dataset, and then leaves. It doesn't see ads and it never subscribes, so the visit earns the business nothing.

The fix is a native way for agents to pay: a few cents for exactly what they use, at the moment they use it.

The web's early architects left room for this. In 1997, the HTTP/1.1 specification reserved status code 402, “Payment Required,” for future use. It has remained alongside the familiar 404 ever since, but without standardized payment semantics for nearly three decades.  In May 2025, Coinbase released x402, an open standard that finally gives 402 its job: when software asks a server for something that costs money, the server names its price in the reply, and the software pays inside the very next request.

The companies that run the world's payments treat this as a trillion-dollar opportunity. On July 14, 2026, the Linux Foundation announced the launch of the x402 Foundation, after Coinbase completed its contribution of the x402 protocol to neutral, open governance.  Forty companies joined the Linux Foundation as members, including Stripe, Visa, Mastercard, American Express, Google, Amazon Web Services, Cloudflare, Shopify, and Circle.

What they're betting on is a surprisingly simple mechanism. In this piece, we'll follow one real transaction from beginning to end: the seller's price sheet, the agent's wallet, the rules that keep the agent in line, and the facilitator that makes sure it all goes smoothly. By the end, you'll see what x402 is really good at, why the biggest names in payments are behind it, and what we've built at Crossmint to power it.

The two cent problem

Start with a job you might hand an assistant today. You ask an AI agent to size up a market before a board meeting. Partway through its research, it needs something it doesn't have: vendor pricing data from a specialized provider. The provider charges two cents per query.

That price is usage-based economics in its purest form. It matches how agents consume the web: one query here, one dataset there, across many providers. But until recently, a price that small couldn't exist online, because there was no way to collect it. Card networks charge merchants roughly 30 cents plus 2 to 3 percent on every sale, and card rails enforce minimum purchase sizes of around 35 cents. That's fine on a $50 purchase; a two-cent sale isn't just unprofitable, it's not allowed.

Sellers fixed this by selling subscriptions. Thousands of queries wrapped into one monthly charge makes every purchase big enough to absorb the fee. But this breaks the match between price and usage: anyone who needs less than the subscription pays for more than they use. Sellers could argue that this business model is good for them because they’re able to capture more money, but it limits the TAM of who’s paying for their services and creates a massive friction point for any potential new buyer.

And subscriptions assume a person is doing the buying. Someone has to create the account, verify the email, and keep a card on file.

Moving the money for a usage-based transaction costs a fraction of a cent, making two cents finally worth collecting. Your agent pays the provider directly, no account needed, gets the data instantly, and hands you the research to nail your board meeting.

Made possible by x402.

Breaking down the transaction

Let’s break down what goes on behind the scenes in an x402 transaction.

The request

The agent sends the provider a web request, the same kind a browser sends when you open a page. No need for credentials. The provider has never heard of this agent and doesn't need to know them.

The price sheet

The provider's server answers with a 402: payment required. Attached is a machine-readable price sheet stating the terms:

“Two cents, payable in USDC, a digital dollar, on Base, a low-cost payment network built by Coinbase, sent to this address.”

To make this sale possible, the provider added one rule to its server: a request without payment gets the price, and a request with valid payment gets the data. That rule replaces the merchant account, the payment processor, and the checkout page a card merchant needs before its first sale.

The wallet, and its rules

The agent reads the price sheet. Before any money moves, the payment has to clear the wallet's rules.

The agent holds a Crossmint agent wallet, a stablecoin account specifically made for agentic commerce that the owner has funded with USDC. These agent wallets are smart contracts, which means rules (like spending guardrails) are enforced at the network layer rather than the app layer. A bug or a manipulated prompt can compromise the app, but it can't touch the account itself, so a payment that breaks the rules fails no matter what.

Because the two-cent charge falls within those limits, the agent’s wallet signs a narrowly scoped authorization to transfer exactly two cents to the provider. The authorization specifies the amount, recipient, and validity window, and the agent attaches it to its next request. No money moves until the authorization is verified and settled.

The facilitator

The provider doesn't take the agent's word for it. It hands the authorization to a facilitator who is the referee of the system. The facilitator in this case is Coinbase (but can be any of these companies as well). They check that the signature is genuine and the funds are real, then submit the payment to the network for settlement.

The facilitator also abstracts away all complexities of stablecoin payments. The provider doesn’t have to manage an onchain balance or touch the underlying network. They just collect payments. The agent doesn't pay the network's transaction fee; the seller's side covers it, the same way merchants cover card processing fees today. Simple for both sides: one pays, one gets paid.

What makes this possible is the authorization the agent signed. It's complete, self-contained permission to move exactly two cents to exactly one address. That means the facilitator can cover the network fee and submit the payment on everyone's behalf.

The network only accepts what the agent's signature approved, so the facilitator can't change the amount, redirect the money, or hold it. Once accepted, two cents leave the agent's wallet and land in the provider's wallet. The provider returns the pricing data. 

About two seconds have elapsed and your agent folds the data into your market report and it feels as if the transaction never happened.

What x402 is powering today and what it will power tomorrow

The subtle magic of x402 makes it perfect for most inputs to knowledge work like published content and datasets.

What’s more interesting is what becomes sellable next:

• Computation and browser time: An agent rents processing or a live browser session for exactly as long as a task runs and can by the second. Platforms such as Browser Use, Browserbase, and Hyperbrowser already provide this infrastructure; x402 could let agents discover and purchase it at runtime without a subscription or prepaid balance.
• Inference: An answer from a specific model can be bought with a small, one-time payment.
• API calls without an account: Any endpoint can charge per call, so an agent that discovered a service can purchase without signing up.
• Crawls: A publisher can charge per page read and turn crawler traffic into revenue. Cloudflare and AWS are both building mechanisms to gate content behind x402 payments, and between them they sit in front of a massive share of the web's traffic.

Crossmint builds the payments piece enabling this future: agent wallets with rules enforced at the network layer, x402 support, and card access through the Visa and Mastercard agent programs, from one integration.

If you're building in agentic commerce, let's chat.