Agentic payments and x402, explained

For thirty years, software could recommend a purchase but never make one on its own. A program could tell you which API to call or which dataset to license, then it stopped and waited. A human entered a card, approved the charge, or set up the subscription. AI agents break that pattern. An agent can plan a task, pick a service, and pay for it in the same motion, with no person at the checkout.

That shift has a name. Agentic payments let software pay for what it uses. Once an agent can hold funds and settle a charge by itself, it stops being a tool that drafts the order and becomes the thing that places it. This is the money layer underneath agentic commerce, the fast-growing world where agents buy data, compute, and services on your behalf.

What are agentic payments?

Agentic payments are transactions an AI agent makes on its own, inside limits you set in advance. The agent buys an API call, a dataset, a unit of compute, or a service, and settles the bill without routing every charge back to a human. You may also see this called agent payments. The terms point at the same idea.

The real change is who holds spending authority. In a normal app, the software prepares a payment and a person confirms it. In an agentic system, you grant the agent a budget and a set of rules once, and from then on it pays as it works. Think of it like a corporate card with a strict limit and an approved-vendor list, handed to an employee who can now buy what the job needs.

It helps to separate two terms that travel together. Agentic payments are the broad category, any payment an agent makes autonomously. x402 is a specific protocol for making those payments over the web. The category is settling on shared rails, and x402 is the one most builders reach for first.

Why don't normal payment rails work for AI agents?

Card networks and checkout flows assume a human is present. Someone reads the total, clicks approve, and clears the occasional fraud check. Hand that flow to an agent and it stalls at the first confirmation screen, or the first time a card gets flagged for unusual activity.

Subscriptions and API keys have the opposite problem. They assume a person signed up ahead of time, agreed to a plan, and put a card on file. An agent that wants to try a new data source for a single query cannot wait for someone to create an account and approve a monthly bill for one request.

Then there is size. Agents tend to make many tiny purchases, sometimes fractions of a cent for a single API call. Card fees alone can cost more than the call itself, which makes micro-purchases on the traditional rails uneconomical.

The gap is easier to see side by side:

Agents need to pay per request, instantly, without a human account behind every charge. That is the gap x402 was built to close.

What is x402?

x402 is an open standard for paying over the web one request at a time, using digital dollars. It revives a piece of the internet that sat unused for decades. The HTTP 402 status code, labeled "Payment Required," has been in the web spec since the 1990s but never had a payment system behind it. (An HTTP status code is the short signal a web server sends back with every response, like 404 for "not found.") x402 finally gives 402 a job.

When a server wants payment, it answers a request with a 402 that states the price and where to pay. The agent pays in a stablecoin, a crypto token pegged to a real-world currency like the US dollar, then repeats the request. No account, no API key, no subscription. The payment rides along with the request.

Because it is an open standard rather than one company's product, any service can accept x402 and any agent can pay it. Since launching in 2025, x402 has processed over 100 million payments, and an industry group now stewards the standard with backing from major payment and technology companies.

x402 turns a single web request into something an agent can pay for on its own, which is exactly the unit agents work in.

How does an x402 payment work?

The flow is short enough to follow end to end:

• The agent requests a resource, say a market-data endpoint.
• The server replies with a 402 and the price, plus the address to pay.
• The agent pays the small amount in stablecoins from its own wallet.
• The agent repeats the request with proof of payment, and the server returns the data.

All of this happens in the background, in well under a second, with no human in the loop. The agent never browses to a checkout page or types in a card. It reads the price, checks the purchase against its budget, pays, and moves on. For a deeper walkthrough of the mechanics, sessions, and facilitators, see how x402 brings real-time crypto payments to the web.

From the agent's point of view, paying for a service is just one more step in finishing the task, no different from making the request itself.

Why do agentic payments settle in stablecoins?

Traditional bank transfers were built for people and businesses, not software. They clear in batches, often pause outside business hours, and slow to a crawl at borders, where a payment can take days and pick up fees along the way. A person planning a purchase can wait for all of that. An agent in the middle of a task cannot, because its next step depends on the payment finishing first.

Stablecoins fit the way agents work. Because a stablecoin holds a steady value pegged to a real currency like the dollar, it can move at internet speed without the price swinging in the seconds it takes to pay. Payments settle in seconds, at any hour, across borders, in amounts as small as a fraction of a cent. Just as important, the balance lives somewhere software can read and move on its own, without waiting on a bank to act for it.

That last point is the one that quietly matters. Crypto rails make money something software can handle directly, the way it already handles data. Once a payment is just another value an agent can check and send, paying for a service stops being a special case that needs a person in the loop.

How do agentic payments power agentic commerce?

Paying for an API is the narrow case. The same rails let agents take part in commerce more broadly, which is why agentic commerce is climbing as both a search term and a business priority. Once an agent can hold funds and settle a charge, it can compare options, buy the one that fits, and pay, without handing control back to a person at the final step.

x402 is not the only way to do this. Other payment standards are emerging for different needs, some built for high-volume sessions, others designed to ride traditional card rails. Most solve the same core problem from a different angle, and a business that wants to accept agent traffic should not have to bet on a single winner. We compare two of the leading approaches in x402 vs MPP, comparing agent payment protocols.

The protocol is plumbing. What matters is that money has become something software can move on its own, and that unlocks a commerce layer that did not exist when every purchase needed a human.

What can you build with agentic payments?

A few patterns are already common:

• Research agents that buy their own data. An agent assembling a report can pay for a premium dataset or a single API call the moment it needs one, then keep going, instead of failing because no one pre-purchased access.
• Services that meter agents by usage. An API provider can charge per call over x402 and serve agent customers who never sign up, never hold a key, and pay only for what they use.
• Autonomous workflows that pay as they run. A pipeline can call paid tools and buy compute, settling each cost in real time, so the work never blocks waiting on a human to approve a vendor.

The common thread is removing the human bottleneck at the moment of payment, which is the one place agents could not previously act on their own.

What do you need to get right?

Giving software the ability to spend money raises an obvious question. What stops it from spending too much, or being tricked into it?

The answer starts with how an agent's identity works. An agent pays from a wallet, and that wallet is controlled by a private key, the secret credential that proves ownership and authorizes every transaction. Whatever the agent can sign with that key, it can spend. So the wallet should be scoped: funded with a small balance, limited to approved recipients, and capped per transaction and per day. Tools like agent wallets in the Alchemy CLI exist to give an agent a wallet it can use without ever holding the raw key itself.

The second risk is instruction. Agents act on text, and text can be manipulated. A malicious prompt buried in a web page or a tool response can try to talk an agent into paying the wrong party. Spending limits and an approved-vendor list turn the worst case from "drained account" into "small, capped loss," which is why those guardrails are not optional.

The rule is simple. Give an agent only the spending authority the task requires, and assume any authority you grant can be misused. Design the limits first, the capability second.

How do you start building agentic payments?

We make both sides of an agentic payment straightforward to stand up.

If you run a service and want to accept agent traffic, AgentPay lets you take payments across x402 and the other emerging protocols through one interface, so you can accept agents today without betting on which standard wins.

If you are building the agent, our infrastructure speaks x402 directly. An agent can pay for blockchain data and RPC access across 100+ networks using USDC on Base, starting from as little as $1 in credits and topping up on its own when the balance runs low, with no dashboard signup and no API key. The Alchemy CLI gives an agent a scoped wallet to sign and pay with, our guide to building onchain agents walks through wiring it together, and agents can even sign up for Alchemy on their own.

If you want the bigger picture first, our explainers on what agent payments are and agentic finance in 2026 go deeper on each piece.

Money is becoming something software can move on its own. The agents are ready. Now the rails are too.

Frequently asked questions

What is the difference between agentic payments and x402?

Agentic payments are the broad category, any payment an AI agent makes on its own within limits you set in advance. x402 is a specific open protocol for making those payments over the web, built on the HTTP 402 status code. Most agents that pay autonomously today use x402, but the category is larger than any single protocol.

What do AI agents use to pay for x402 requests?

Agents pay in stablecoins, crypto tokens pegged to a real currency like the US dollar, so the amount holds its value while it settles in seconds. On Alchemy, an agent can pay for blockchain data across 100+ networks using USDC on Base, starting from as little as $1 in credits and topping up on its own.

How much does an x402 payment cost?

There is no subscription or account fee. An agent pays only the price the server sets for each request, which can be a fraction of a cent, plus a small network fee to settle the payment onchain. That makes tiny, per-call purchases practical in a way traditional card rails are not.

How do you stop an AI agent from overspending?

Fund the agent's wallet with a small balance and scope what it can do. Cap spending per transaction and per day, and limit it to approved recipients. Because the wallet is controlled by a private key the agent signs with, the safe rule is to grant only the spending authority the task actually needs.

Which blockchains does x402 work with?

x402 began on Base and, since its V2 update in December 2025, works across several networks including Solana, Ethereum, and Polygon. Because it is an open standard rather than one company's product, any service can accept it and any agent with a funded wallet can pay.

Do you need a crypto background to accept agent payments?

No. A service can accept agent traffic without writing blockchain code. Alchemy's AgentPay handles payments across x402 and other emerging protocols through one interface, so you can start accepting agents without picking a winning standard or managing wallets and settlement yourself.