AI Agent Payments in 2026: x402 vs AP2 vs ACP
Your agent has a wallet now. Three protocols showed up to tell it how to use one, and the most common mistake is treating them as rivals: x402 moves the money, AP2 proves a human said it could, and ACP agrees the cart with the merchant. Here is what each one does, what the adoption numbers really say, and what to implement this quarter.
First: why agents need payment rails of their own
The obvious way to let an agent buy something is to hand it your card details. That instinct is also the reason this entire category exists, because it fails in four specific ways and every one of them is expensive.
Understanding these four is most of the work. Once you can name the failure you are trying to prevent, the protocol comparison below stops being an alphabet soup and starts being a shortlist.
A card has no scope
It authorizes everything, everywhere, until you cancel it. An agent that misreads a page can spend to your limit, and nothing in the rail itself says it should not have been allowed to.
There is no proof of consent
When the charge is disputed, "the user told the assistant to" is a chat transcript. That is not something a chargeback process, an auditor or a regulator can act on.
The unit is wrong
Card rails are built for dollars, not for a third of a cent. An agent making thousands of API calls an hour cannot pay per call through a system with a fixed transaction fee and an account signup.
Prompt injection becomes a financial exploit
An agent that reads the web and holds spending authority can be instructed by a page it visits. Scoped credentials turn that from a drained card into a single bad purchase.
None of this is urgent for most products. If no agent is buying from you yet, and you are not selling per-call access to software, then Stripe Checkout and a pricing page an agent can parse are the whole job. Everything below is about what to build when that changes — and for a lot of teams in 2026 the honest answer is "not this quarter".
Quick Verdict
Settlement. Stablecoins over HTTP, no accounts, no API keys. Already doing tens of millions of tiny machine-to-machine payments a month.
Authorization. Signed mandates that carry proof a human allowed this spend, scoped by category, amount and expiry. Not a rail — it rides on whatever rail you use.
Checkout. Four REST endpoints and a Shared Payment Token scoped to one merchant and one amount. The path a consumer agent actually takes to buy from you.
TL;DR
Selling API calls or compute to software? x402. Selling goods to people whose agents buy for them? ACP. Need to prove consent to a counterparty or an auditor? AP2. Most real systems will end up touching two of the three.
They stack. They do not compete.
Almost every "protocol war" take on agentic payments is wrong, because the three specs answer three different questions about the same purchase:
"Was this allowed?" → AP2
The user signs a mandate: this agent may spend up to this much, in these categories, until this date. The agent presents it; the merchant verifies the signature and checks the scope before taking money.
"What exactly is being bought?" → ACP
Create a checkout session, update it as the cart changes, complete or cancel it. A Shared Payment Token carries spending authority scoped to that one merchant and that one amount.
"How does the money actually move?" → x402
The server answers HTTP 402 with payment instructions, the client signs a stablecoin transfer into the request header, and a facilitator verifies and settles it. Sub-second, sub-cent-capable, no account.
A complete transaction in 2026 can use AP2 to prove the user authorized the purchase, ACP to negotiate the cart with the merchant, and x402 to settle. That composition is the point — and it is also why picking "the winner" is the wrong exercise.
x402: the HTTP status code that waited 30 years
HTTP 402 "Payment Required" has been reserved and unimplemented since the early web. Coinbase released x402 in May 2025 to finally use it, and the flow is genuinely simple: request a paid resource, get a 402 back with an amount, currency and destination, sign a payment, resend the request with the payment in a header, receive the resource.
V2 landed in December 2025 with wallet-based identity, dynamic payment recipients and multi-chain support. Coinbase's CDP facilitator verifies the signed payload, submits settlement and runs KYT screening without ever taking custody of the buyer's funds, with documented production endpoints across Base, Polygon, Arbitrum, World and Solana.
75.41M
transactions, trailing 30 days
As read on the x402 dashboard, 2 September 2026.
$24.24M
value over the same window
Roughly 32 cents per transaction on average.
~69K
active agents (April 2026)
Against ~165M cumulative transactions and ~$50M moved.
Read those two numbers together
Seventy-five million payments is a genuinely large number. Twenty-four million dollars is a genuinely small one. The shape tells you precisely what x402 is today: agents paying per call for API access, data and compute — not people buying trainers. If your product sells software to software, that is your market. If it sells physical goods, x402 is not yet where your customers are.
You do not need a crypto balance sheet. Stripe integrated x402 on Base in February 2026, so settlement happens in USDC while the merchant takes proceeds in fiat. In practice that makes x402 dollar-denominated stablecoin rails with a conventional off-ramp attached.
AP2: consent you can verify later
The Agent Payments Protocol was introduced by Google Cloud and Coinbase in September 2025, built on top of A2A and MCP, and backed by more than 60 organizations. Its central idea is the mandate: a signed credential carrying scope — permitted categories, an amount ceiling, an expiry — that the agent presents at purchase time.
AP2 is not a payment method, and reading it as one is the most common misunderstanding. It is a way of proving that a person told an agent it could spend, and of carrying that proof to whoever eventually takes the money. It is deliberately payment-agnostic: the same mandate can sit in front of a card charge or a stablecoin transfer.
Why it exists
When an agent buys something and the user disputes it, someone has to answer "who authorized this?". Today that answer is a chat transcript. AP2 replaces it with a signature and a scope the merchant checked before settling — which is what a chargeback process, an auditor, or a regulator can actually work with.
Where it is weak
Mandates are only as good as the merchants that verify them. Adoption is broad on paper — 60-plus organizations — and thin in checkout flows you can actually hit today. Treat AP2 as the standard to design toward rather than the one to depend on this quarter.
ACP: the one your customers will arrive on
The Agentic Commerce Protocol is Stripe and OpenAI's spec for how an agent checks out at a merchant. It is refreshingly boring: four REST endpoints to create, update, complete and cancel a checkout session, plus Shared Payment Tokens that scope spending authority to a single merchant and a single amount.
Stripe extended this in April 2026 with Link Agents, launched at Sessions on 29 April, which lets Stripe-managed wallets approve fiat purchases for Claude and OpenAI agents through the same Shared Payment Token mechanism. If you sell to consumers, this is the concrete integration to care about — it is the route a mainstream assistant will take to your checkout.
Practical note: a Shared Payment Token that is scoped to one merchant and one amount fails safe. If an agent is manipulated — by a prompt injection on a page it read, say — the blast radius is one purchase at one shop, not a drained card. That property is worth more than any of the throughput numbers in this article.
Protocol comparison
What nobody has solved: metering
Three specs now agree on how to authorize a payment and how to settle it. None of them tells you how to count what the agent used before the charge. That gap falls entirely on you, and it is where most teams building a paid agent tool spend their engineering time.
Pricing a call you cannot predict
If your endpoint runs an LLM, the cost of serving a request varies by an order of magnitude with input length. A fixed 402 price either loses money on long requests or overcharges short ones, and there is no standard way to quote dynamically before the work is done.
Refunds and disputes across layers
A purchase authorized by an AP2 mandate and settled over x402 has no unified dispute path. Unwinding it means reconciling a signed credential against an on-chain settlement, by hand, today.
Prompt injection is now a financial risk
An agent that reads the web and holds spending authority can be instructed by a page it visits. Scoped credentials — AP2 mandates, ACP Shared Payment Tokens — are the mitigation, and the reason you should never hand an agent a general-purpose key.
For scale context: McKinsey estimates agentic commerce could influence $3–5 trillion in global commerce by 2030. Treat that as a direction of travel rather than a forecast to build a business plan on — but the infrastructure question it implies is real, and it is being answered now.
What should you implement?
You sell API calls, data, or compute
Implement x402. Per-call, sub-dollar, no account system, no key management — this is the exact workload the 75 million monthly transactions are made of. Use a facilitator rather than settling yourself, and take fiat on the other side if you want to.
You sell goods or services to consumers
Implement ACP through Stripe. Four endpoints, Shared Payment Tokens, and — via Link Agents since April 2026 — a path that Claude and OpenAI agents can actually walk to your checkout. This is the integration with real customers behind it today.
You need to prove who authorized a spend
Design toward AP2. Regulated flows, B2B procurement, anything with a chargeback or an auditor at the end of it. Mandates give you a verifiable answer to "who said yes" that a chat log never will.
You are a solo founder and this is not your problem yet
Then it genuinely is not. Ship Stripe Checkout, keep your pricing page human-readable so an agent can parse it, and revisit when a customer asks. The cost of waiting on this one is low; the cost of building a settlement layer you did not need is not.
Frequently Asked Questions
What is x402?
x402 is an open payment protocol from Coinbase that revives the long-unused HTTP 402 "Payment Required" status code. A client requests a paid resource, the server answers 402 with payment instructions — amount, currency, destination — the client signs a stablecoin payment, attaches it to the request header, and gets the resource. No accounts, no sessions, no API keys. It launched in May 2025, and V2 arrived in December 2025 with wallet-based identity, dynamic payment recipients, and multi-chain support.
What is the difference between x402, AP2, and ACP?
They do different jobs and they stack. AP2, from Google Cloud and Coinbase, is an authorization framework: cryptographically signed mandates that prove a human told the agent it could spend, scoped by category, amount and expiry. ACP, from Stripe and OpenAI, is a checkout spec: four REST endpoints to create, update, complete or cancel a checkout session, plus Shared Payment Tokens scoped to one merchant and one amount. x402 is settlement: stablecoins moving over HTTP. A full transaction can use AP2 to prove consent, ACP to agree the cart, and x402 to move the money.
Is x402 actually being used, or is it a demo?
It is genuinely in production, at a very particular shape. Read on 2 September 2026, the x402 dashboard showed 75.41 million transactions worth $24.24 million over the prior thirty days — an average of roughly 32 cents each. That is not retail commerce; it is agents paying per call for APIs, data and compute. Seventy-five million payments is a large number and $24 million is a small one, and the gap between them tells you exactly what the protocol is for today.
Do I need crypto to accept agent payments?
No. AP2 is deliberately payment-agnostic and works over card rails. ACP runs on Stripe with ordinary card processing. And Stripe integrated x402 on Base in February 2026, which means a merchant can settle in USDC and take the proceeds in fiat — stablecoin rails with a normal off-ramp. If your objection to agent payments is that you do not want a crypto balance sheet, that objection has an answer in 2026.
Which agentic payment protocol should I build on?
If you sell API calls, data or compute to other software, implement x402 — the per-call, sub-dollar pattern is exactly what it was designed for and it needs no account system. If you sell goods or services to consumers whose agents will buy on their behalf, implement ACP through Stripe, because that is the path an OpenAI or Claude agent will actually arrive on. Look at AP2 when you need to prove to a counterparty, an auditor, or a chargeback process that a human authorized the purchase.
How do I stop an agent from overspending?
Scope the credential, do not trust the prompt. AP2 mandates carry explicit scope — permitted categories, amount ceilings, an expiry — and the merchant verifies the signature and checks the scope before settling. ACP Shared Payment Tokens are scoped to a single merchant and a single amount, so a leaked token buys one thing once. Both designs assume the agent will eventually do something unintended, which is the correct assumption.
What is still missing from the agent payment stack?
Metering. The protocols agree on how to authorize and how to settle, but almost nothing standardizes how usage is counted before the charge — which is the part every developer building a paid agent tool actually has to write. Reconciliation, refunds, and dispute handling across an AP2 mandate plus an x402 settlement are also largely unsolved, and are where most production implementations spend their engineering time.
Related Articles
The processor underneath all of this
MCP in 2026: Complete GuideAP2 is built on top of it
Browser Infrastructure for AI AgentsHow the agent reaches the checkout
AI Agents for a One-Person BusinessAgents that transact on your behalf
LangGraph vs CrewAI vs AutoGenWhere the spending decision happens
How to Build a SaaS from ScratchBilling before agent rails