Five agentic payment protocols dominate 2026 — ACP, AP2, x402, MPP, and Visa TAP — and the secret is that they compose rather than compete. Here is what each does, where it sits, and which to use.
What are agentic payment protocols?
Agentic payment protocols are standards that let an AI agent pay for something on a user’s behalf — proving who authorized the purchase, checking out with the merchant, and moving the money. In 2026 five of them dominate: ACP, AP2, x402, MPP, and Visa’s Trusted Agent Protocol (TAP). The single most important thing to understand is that they compose more than they compete — each solves a different layer of the same problem.
That framing matters because most comparisons treat them as rivals fighting for one slot. They are not. An agent can carry a Google AP2 mandate into an OpenAI ACP checkout that settles over Coinbase’s x402 — three protocols, one transaction. Here is the landscape at a glance before we break down each layer.
Agentic payment protocols split into three jobs: authorization (did the user consent? — AP2, Visa TAP), checkout (how does the merchant get paid? — ACP), and settlement (how does the money actually move? — x402, MPP).
| Protocol | Who | Layer | What it does |
|---|---|---|---|
| ACP | OpenAI + Stripe | Checkout | Agent-to-merchant checkout via a scoped Shared Payment Token |
| AP2 | Authorization | Cryptographic ‘mandates’ proving the user authorized the purchase | |
| x402 | Coinbase | Settlement | Instant stablecoin payments over HTTP (revives the 402 status code) |
| MPP | Stripe + Tempo | Settlement | Session-based streaming micropayments, batched on-chain |
| Visa TAP | Visa + Cloudflare | Trust / identity | Signs the agent’s identity into requests; merchants verify it |
The three layers: authorization, checkout, and settlement
Every agentic payment splits into three layers, and each protocol targets one of them. Get this mental model and the whole space becomes legible.
Authorization answers ‘did the human actually approve this?’ Google’s AP2 does it with signed mandates; Visa’s TAP does it by verifying the agent’s cryptographic identity. Checkout answers ‘how does this specific merchant get paid?’ — that is ACP’s job, issuing a payment token scoped to one merchant and one amount. Settlement answers ‘how does the money move?’ — card networks for consumer buys, or stablecoin rails like x402 and MPP for high-frequency, machine-to-machine spend.
Because the layers are separable, you mix and match: the consent artifact from one protocol can ride into a checkout from another and settle on a third.
“Stop asking which agentic payment protocol wins. Ask which layer it solves — authorization, checkout, or settlement.”
The mental model that makes the space legible
The five agentic payment protocols, scored
Here is each protocol on its own terms — what it is, where it shines, and where it stops. Scores reflect maturity and fit for their layer, not a head-to-head ranking (they do different jobs).
ACP — Agentic Commerce Protocol
Best for: Consumer purchases inside an assistant (ChatGPT Instant Checkout)
What works
Watch out for
AP2 — Agent Payments Protocol
Best for: Proving user consent that must persist across rails
What works
Watch out for
x402
Best for: Agent-to-agent infra payments (APIs, compute, data)
What works
Watch out for
MPP — Machine Payments Protocol
Best for: Metered, per-call machine spend at scale
What works
Watch out for
Visa Trusted Agent Protocol (TAP)
Best for: Letting merchants verify a real, authorized agent
What works
Watch out for
How agentic payment protocols compose in production
In production, agents rarely pick one protocol — they run a stack. A typical 2026 setup uses card rails through ACP for consumer-facing purchases, stablecoin rails through x402 or MPP for the infrastructure layer (compute, data, model inference), and an AP2 mandate as the authorization layer where the user’s consent has to persist across both.
Concretely: your shopping agent gets a signed AP2 mandate from you (‘buy this cart, up to $200’), carries it into an ACP checkout that issues a single-use token to the merchant, and a card network settles it — while the same agent pays for the API calls it made along the way over x402 in USDC. One task, three layers, four protocols, no conflict.
Authorization (AP2 / Visa TAP) + checkout (ACP) + settlement (x402 / MPP). Build to the layers and you can swap any single protocol without re-architecting the others.
Which agentic payment protocol should you use?
Verdict: adopt a layer, not a logo
Pick by use case, not by brand. If your agent buys consumer goods inside an assistant, start with ACP for checkout on card rails. If it makes high-frequency machine-to-machine payments for APIs, compute, or data, use x402 (one-off stablecoin calls) or MPP (metered streaming). If you need provable user consent that survives across rails, layer AP2 mandates on top. If you are the merchant deciding whether to trust an incoming agent, implement Visa TAP verification.
Authorization (AP2 / Visa TAP) → checkout (ACP) → settlement (x402 / MPP). Build the stack, not the bet.Builder’s take
Wiring payments into Cyntr’s agents, the thing that finally made the agentic payment protocols landscape click for me was to stop asking ‘which one wins’ and start asking ‘which layer is this.’ Once you see ACP as checkout, x402 and MPP as settlement, and AP2 and Visa TAP as authorization and trust, the supposed rivalry dissolves into a stack.
- Don’t pick one protocol — pick one per layer: an authorization layer, a checkout path, and a settlement rail.
- Card rails (ACP) for consumer purchases, stablecoin rails (x402/MPP) for agent-to-agent infrastructure spend like compute and inference.
- Keep the user-consent artifact (an AP2-style mandate) separate from the money movement, so consent survives across whichever rail settles.
- Scope every token hard: merchant-bound, amount-bound, time-bound, single-use. An unscoped agent payment token is a blank cheque.
Frequently asked questions
Standards that let an AI agent pay on a user’s behalf. They split into three layers: authorization (proving the user consented — AP2, Visa TAP), checkout (paying a specific merchant — ACP), and settlement (moving the money — x402, MPP). The five leading protocols in 2026 compose rather than compete.
ACP (OpenAI + Stripe) is a checkout protocol that issues a scoped payment token to a merchant. AP2 (Google) is an authorization framework that proves the user consented, via signed mandates. An agent can carry an AP2 mandate into an ACP checkout — they work together, not against each other.
x402 is Coinbase’s protocol for instant stablecoin payments over HTTP. It revives the 402 ‘Payment Required’ status code: the server returns 402 with payment instructions, the client signs a USDC payment into the request header, and gets the resource — one round trip, multi-chain.
MPP, from Stripe and Tempo (launched March 2026), uses session-based pre-authorization so agents can stream many micropayments that batch into fewer on-chain transactions, with sub-second finality and no gas token. It targets high-frequency, metered machine-to-machine spend.
It depends on the layer. Consumer retail checkout → ACP on card rails; agent-to-agent infrastructure payments → x402 or MPP on stablecoins; cross-rail user consent → AP2 mandates; merchant-side agent verification → Visa TAP. Most production agents combine several.
Mostly no. ACP, AP2, x402, MPP, and Visa TAP target different layers — authorization, checkout, settlement, and trust — and are designed to interoperate. The realistic 2026 architecture uses one protocol per layer.
Primary sources
- Agentic payments protocols compared (MPP, ACP, AP2, x402) — Crossmint
- AI agents need payment rails: MPP, ACP, AP2, x402 explained — CCN
- Agentic Commerce Protocol (ACP) — OpenAI
- AP2 — Agent Payments Protocol — Google
- x402 — open payments over HTTP — Coinbase
- Stripe + Tempo: the Machine Payments Protocol — Stripe
Last updated: May 30, 2026. Related: Commerce.
