Your AI agent is mid-task and needs a paid API - it has no credit card, can't fill in a billing form, and can't "subscribe then cancel". Your options: a prepaid key (fragile) or stopping to ask a human (which defeats autonomy). This is the last mile of agent autonomy: before agents can earn, they must learn to spend. Over the past year, five protocols rushed into that gap almost simultaneously: Stripe's MPP, Coinbase's x402, Stripe+OpenAI's ACP, Google's AP2, and Visa's TAP. This review puts them on one table.
Scope note: this is a representative comparison based on official docs and public technical analyses (HyperTrends, Techstrong, Crossmint, AWS; as of 2026-08), not a hands-on integration benchmark. All five are evolving fast - official docs rule. Crypto-asset mentions are not investment advice.
1. The Master Table: Five Protocols, Five Philosophies
| Protocol | Backer | Rail | One-line philosophy |
|---|---|---|---|
| MPP | Stripe + Tempo (launched 2026-03-18) | Tempo L1 stablecoin-native + fiat (cards/BNPL via SPT tokens) | Pre-authorized sessions + streaming micropayments, built into a settlement-network runtime |
| x402 | Coinbase (stewarded by the x402 Foundation) | Stablecoins (USDC), chain-agnostic (Base/Polygon/Solana…) | Payments should be as native as HTTP status codes: 402 = pay first, then served |
| ACP | Stripe + OpenAI | Traditional card rails (Stripe Checkout) | Bring the checkout experience to agent commerce, with humans in the loop |
| AP2 | Rail-agnostic (authorization-layer protocol) | Authorization first: define what an agent may spend before it spends | |
| TAP | Visa | The Visa network | Issue agents identity certificates; extend the card network's trust model to agents |
Note they don't all compete at the same layer: x402/MPP are payment-execution protocols (how money moves), AP2 is an authorization protocol (how much is allowed, to whom), ACP is a commerce-flow protocol (discover -> checkout -> fulfill), TAP is identity + clearing. Real systems will stack them - e.g., AP2 sets policy while MPP or x402 executes.
2. One by One: Where Each Wins
x402: the most hacker-friendly, fastest to land. It revives the HTTP 402 status code that has sat unused for nearly 30 years: request -> server answers 402 + a payment spec (amount, wallet, chain) -> the agent's wallet signs a stablecoin payment -> resubmit with payment proof -> 200 + data. Zero accounts, zero API keys, zero subscriptions - true $0.001 micropayments work. The official repo is x402-foundation/x402 (6,518 stars, TypeScript; API snapshot 2026-08-17), and Coinbase launched the Agent.market directory in April 2026. Costs: stablecoin compliance hurdles (risk-averse enterprise teams will balk), L2 settlement in seconds rather than milliseconds, and an early ecosystem. On-chain analytics firm Range has reported over 75 million transactions and about $25 million of volume settled over x402 in a 30-day window (social-media-sourced figure, unaudited - treat as indicative).
MPP: the most "bank-grade", closest to real payments UX. Co-published by Stripe and Tempo (the payments L1 co-built by Stripe and Paradigm). Two designs worth remembering: the sessions primitive - an agent pre-authorizes a spending cap and streams micropayments within the session, without a per-interaction on-chain transaction; and SPTs (Shared Payment Tokens) - you never hand an agent a raw card number; SPTs are programmable, time-limited, context-bound authorizations. For Stripe merchants, agent payments land in the same Dashboard as human ones - tax, fraud, refunds all reused. Stripe is simultaneously backing MPP, ACP, and x402 support - its usual multi-rail playbook.
ACP: the most enterprise-friendly, the least "autonomous". Three roles: buyer agent, seller agent, Stripe Checkout. Flow: discover capabilities -> get a checkout URL -> pay (route to human approval above a threshold) -> webhook confirms -> fulfill. It rides the world's most familiar card rails and supports subscriptions, invoicing, multi-party payments; but the checkout redirect breaks the pure machine-to-machine loop, and card fees make $0.001 micropayments uneconomical. Best for high-value B2B.
AP2: the most governance-friendly, but it doesn't execute. The core is the APA (Agent Payment Authorization) policy document: per-transaction/per-day/per-vendor limits, approved vendor categories, above-threshold approval flows, audit-trail requirements. It answers "what is the agent allowed to do" and deliberately not "how the money moves" - execution needs a separate rail. Suits procurement automation, regulated industries, multi-agent governance.
TAP: the incumbent's play. A business registers its agent with Visa and receives an Agent Identity Certificate - a cryptographic credential identifying the agent, its owner, and its authorized spending parameters. Merchants validate via Visa's network; settlement runs on standard Visa rails. Tens of millions of merchants can accept agent money overnight - provided you accept living entirely inside card-network rules.
3. How to Choose: A Decision Table
| Your scenario | Pick | Why |
|---|---|---|
| Selling APIs per-call, dev-to-dev services, micropayment-heavy | x402 | True pay-per-call, no account friction, one npm wrapper around fetch |
| Already on Stripe for SaaS/API billing | MPP | Dashboard/tax/fraud reused; sessions skip per-payment settlement |
| B2B high-value, human approval, subscriptions/invoicing | ACP | Card rails + human-in-the-loop; easiest compliance story |
| Enterprise multi-agent procurement, heavy audit | AP2 (+ any execution rail) | The most complete authorization layer; govern first, then spend |
| Widest merchant reach, accept card-network rules | TAP | Visa's validation and clearing reused as-is |
Three cross-cutting disciplines: micropayments favor stablecoin rails, large tickets favor fiat rails; governance lives in the authorization layer - don't expect execution protocols to manage risk for you; every protocol here is young - keep a replaceable abstraction so you never weld yourself to one.
4. For the Undecided: What to Actually Do Now
HyperTrends cites a Deloitte survey in which 57% of executives expect agentic payments to mainstream within three years, with market projections of $3-5 trillion by 2030 (institutional projections - consume with salt). For developers, the pragmatic move today isn't betting on a protocol; it's: (1) reshaping your API/service into a meterable, per-call billable form (the common prerequisite of every protocol), and (2) landing a limits-plus-audit layer on your own agents (the AP2 pattern) - the concrete steps are in our AI Agent Payments Integration SOP. When the standards converge, you'll already be at the table.
FAQ
Q1: Are these five protocols competitors? Will only one survive? A1: Mostly they coexist in layers: x402/MPP execute payments, AP2 authorizes, ACP runs the commerce flow, TAP handles identity and clearing. Real systems combine them (AP2 policy + MPP execution). The genuine head-to-head is execution-layer x402 vs MPP - and Stripe itself supports both.
Q2: I want nothing to do with crypto - is there a pure fiat path? A2: Yes. ACP runs on traditional card rails; MPP's fiat path supports cards and BNPL via SPT tokens; TAP runs straight on Visa's network. x402 is the most stablecoin-native of the five - compliance-conservative teams should skip it for now.
Q3: What is an SPT and why does it matter? A3: A Shared Payment Token - a programmable, time-limited, context-bound payment authorization in MPP. It solves the most basic security problem: you cannot hand an AI agent a raw credit-card number. The agent receives a scoped temporary credential, not your actual payment secret.
Q4: Is integrating now too early - am I about to pick a loser? A4: Betting the business on a single protocol is early. Building the prerequisites isn't: a metered, per-call billable API and an agent-side limits/approval/audit layer are needed no matter which protocol wins. Do those two first; adopt the protocol layer after convergence.
Q5: Any specifics for teams operating under Chinese regulation? A5: All five protocols currently center on USD rails and global merchants, and stablecoin/cross-border payment activity is regulated in China. The realistic path for China-based teams is to experiment inside internal sandboxes or overseas business lines, and to build the protocol-agnostic controls (spending limits + audit) first. Background in our Stripe-OpenRouter hotspot piece.
References
- HyperTrends (2026-04-02): "Agentic Payments: The Complete Protocol Comparison (x402 vs ACP vs AP2 vs TAP)"
- Techstrong.ai: deep dive on Stripe's MPP (sessions primitive, SPT tokens, Tempo mainnet, architectural contrast with x402)
- Crossmint Learn: MPP/ACP/AP2/x402 side-by-side; The Defiant: Tempo mainnet live with MPP (2026-03-18)
- Tempo official blog: "Tempo Mainnet is live"; AWS Industries: x402 and agentic commerce in financial services
- GitHub: x402-foundation/x402 (6,518 stars, API snapshot 2026-08-17); npm: x402-fetch (Coinbase, Apache-2.0)
- eco.com / Solana official x402 docs: Agent.market (April 2026), chain-agnostic design
- Range (on X): ~75M transactions / ~$25M volume over x402 in a 30-day window (social-media-sourced, unaudited)
- Related: Stripe-OpenRouter Hotspot, AI Agent Payments Integration SOP
A representative comparison (not a hands-on benchmark); protocol details per official docs. Crypto-asset mentions are not investment advice.