AI agents are spending money. Not in a theoretical sense — Stripe processed $1.9 trillion in payment volume in 2025, and its newest infrastructure is purpose-built for autonomous software buyers. Google has rallied 100+ partners around an authorization standard for agent-initiated payments. Coinbase's x402 protocol has processed over 140 million transactions. And a new blockchain called Tempo launched specifically to be the settlement layer for machine payments.
Four protocols have emerged as the defining standards for how agents and machines will pay for services: MPP, x402, ACP, and AP2. They don't compete — they solve different problems at different layers. This guide breaks down what each does, how they compare, and how to decide what to implement.
The Four Protocols at a Glance
| Protocol | Created By | Layer | What It Solves | Payment Rails |
|---|---|---|---|---|
| x402 | Coinbase | Settlement / execution | Machine-to-machine payments via HTTP 402 | Stablecoins (USDC on Base, Solana) |
| MPP | Stripe & Tempo | Settlement / sessions | Streaming micropayments with session pre-authorization | Stablecoins + fiat cards + Bitcoin Lightning |
| ACP | OpenAI & Stripe | Checkout / merchant integration | Agent-to-merchant purchasing flows | Fiat (cards, digital wallets via Stripe) |
| AP2 | Authorization / trust | Proving an agent has permission to spend | Payment-agnostic (framework layer) |
x402: Permissionless Machine Payments
x402 is the protocol that revived HTTP's long-dormant 402 "Payment Required" status code. Created by Coinbase and open-sourced under Apache 2.0, x402 makes payment a first-class part of the HTTP protocol stack.
How it works
A client requests a resource. The server responds with 402 Payment Required and a structured JSON payload specifying the price, accepted asset (typically USDC), and settlement network. The client signs a payment authorization using its wallet. A facilitator verifies and settles the transaction on-chain. The server delivers the resource.
The entire flow happens within a single HTTP request cycle. No accounts, no API keys, no subscriptions — just an HTTP request and a wallet.
When to use x402
x402 is ideal for pay-per-request API monetization, machine-to-machine data feeds, and any scenario where you want fully permissionless, crypto-native settlement. It shines when the buyer and seller have no pre-existing relationship. A machine can discover an x402-enabled endpoint, pay for it, and consume the response — all without ever creating an account.
The trade-off is that x402 is stablecoin-only and stateless by design. Every request is an independent payment event. For high-frequency micropayments (thousands of calls per session), the per-request settlement model can become expensive even on L2s, though facilitator batching mitigates this. v2 of the specification added wallet-based identity, receipts, and replay protection to address the statefulness gap.
Key numbers
x402 has processed over 140 million cumulative transactions with $600+ million in payment volume. At peak throughput in October 2025, the protocol handled roughly 1 million transactions per week. Cloudflare co-founded the x402 Foundation in September 2025, signaling that edge infrastructure is becoming payment-aware.
MPP: Enterprise-Grade Machine Payments
MPP (Machine Payments Protocol) was co-authored by Stripe and Tempo — a Layer 1 blockchain incubated by Stripe and Paradigm. It launched on March 18, 2026 alongside Tempo's mainnet, backed by a $500 million Series A at a $5 billion valuation.
How it works
MPP also uses the HTTP 402 status code, but adds a session layer on top. Instead of settling each request individually, an agent pre-authorizes a spending limit — analogous to opening a tab at a bar. The agent then consumes resources and streams micropayments continuously, with all payments within the session batch-settling into a single on-chain transaction. Stripe describes this as "OAuth for money."
The settlement layer is Tempo, a purpose-built payments blockchain with approximately 0.5-second deterministic finality, no re-orgs, and dedicated payment lanes that separate payment traffic from smart contract activity. Critically, Tempo has no native gas token — fees are paid in stablecoins via a protocol-native AMM.
MPP is rail-agnostic. It supports stablecoins on Tempo, fiat cards via Stripe (Visa, Mastercard), buy-now-pay-later providers (Affirm, Klarna), and Bitcoin via Lightning through Lightspark. Payments flow into the merchant's existing Stripe dashboard alongside traditional revenue.
When to use MPP
MPP is the right choice when you need streaming micropayments with session-based pre-authorization, fiat and crypto support on the same endpoints, or Stripe integration for compliance, fraud protection, and merchant tooling. It's designed for enterprises that want machine payments without leaving the Stripe ecosystem.
The trade-off is that MPP is more opinionated than x402. It assumes Stripe as the payment processor and Tempo as the settlement chain. The integration requires the Stripe API and uses SharedPaymentTokens — a Stripe-specific mechanism. This makes it less permissionless than x402 but significantly more enterprise-ready.
Key numbers
MPP launched with 100+ integrated service providers, including Browserbase, DoorDash, Nubank, Ramp, and Revolut. Extension partners include Visa, Mastercard, and Lightspark. Design partners include Anthropic, OpenAI, and Shopify.
ACP: Agent-to-Merchant Checkout
ACP (Agentic Commerce Protocol), created by OpenAI and Stripe, standardizes how AI agents interact with merchants to complete purchases. If x402 and MPP are about machines paying machines, ACP is about agents buying things from stores.
How it works
ACP defines four RESTful HTTP endpoints that model the checkout lifecycle: Create Checkout (agent sends a SKU, merchant creates a cart), Update Checkout (agent modifies quantities, shipping, customer details), Complete Checkout (agent provisions a SharedPaymentToken scoped to a specific amount and merchant, merchant processes payment), and Cancel Checkout (releases held inventory).
The key innovation is the SharedPaymentToken (SPT) — a single-use, time-bound, amount-scoped payment token that lets an agent pay on behalf of a user without ever touching raw card credentials. If the merchant tries to modify the amount, Stripe rejects the charge. The merchant remains the system of record for orders, taxes, and compliance throughout.
When to use ACP
ACP is designed for conversational commerce — an AI agent shopping on behalf of a human user. Think of an agent browsing a retailer's catalog, comparing options, and completing a purchase through dialogue. It's the right protocol when the transaction involves physical or digital goods with structured checkout flows, and when a human user is still the principal behind the purchase (even if they're not clicking buttons).
The trade-off is that ACP is fiat-only (cards and digital wallets through Stripe) and designed for human-present scenarios. It doesn't handle machine-to-machine micropayments, API monetization, or stablecoin settlement. It's a checkout protocol, not a settlement protocol.
Key numbers
ACP's first major deployment was OpenAI's Instant Checkout in ChatGPT, launched in February 2026 with Etsy sellers. Partners include Stripe, Shopify, Salesforce, PayPal, and brands like URBN (Anthropologie, Free People, Urban Outfitters), Coach, Kate Spade, and Revolve.
AP2: Authorization and Trust
AP2 (Agent Payments Protocol), created by Google with over 100 industry partners, solves a different problem entirely: how does a merchant or service know that an agent is authorized to spend money?
How it works
AP2 uses Verifiable Digital Credentials (VDCs) — cryptographically signed mandates based on the W3C Verifiable Credentials standard. Three mandate types cover different authorization scenarios:
- Intent Mandate — Captures conditions under which an agent can purchase autonomously (price limits, timing, categories). Used when the human is not present at the moment of transaction.
- Cart Mandate — Captures the user's explicit authorization for a specific cart with exact items and total. Used when the human reviews and approves before the agent completes the purchase.
- Payment Mandate — Shared with the payment network to signal AI agent involvement and help issuers assess risk.
AP2 functions as an extension for Google's A2A (Agent-to-Agent) protocol and MCP (Model Context Protocol). It doesn't move money itself — it proves that the entity requesting the payment has the authority to do so.
When to use AP2
AP2 is essential for enterprise deployments where auditability and non-repudiation matter. Every agent-initiated transaction carries a cryptographic proof of user intent. This is critical for compliance-heavy industries — finance, healthcare, procurement — where "who authorized this?" needs an answer that holds up in court.
AP2 is payment-agnostic. It works with cards, real-time payment systems (UPI, PIX on the roadmap), and digital currencies. Google has launched an A2A x402 extension in collaboration with Coinbase for agent-based crypto payments, showing how AP2 and x402 compose together.
Key numbers
Partners include Adyen, American Express, Coinbase, Mastercard, PayPal, Visa, Shopify, Worldpay, UnionPay International, and more. Mastercard committed to enabling all U.S. cardholders for agent commerce by holiday season 2025.
How the Protocols Fit Together
The most important insight about these four protocols is that they operate at different layers and are designed to be combined:
| Layer | Protocol | Question It Answers |
|---|---|---|
| Authorization | AP2 | "Is this agent allowed to spend?" |
| Checkout | ACP | "How does the agent complete a purchase?" |
| Settlement | x402, MPP | "How does the money actually move?" |
A real-world agent workflow might look like this:
- A user creates an AP2 Intent Mandate authorizing their agent to purchase compute resources up to $50 per day.
- The agent discovers a cloud GPU provider that supports ACP for structured checkout or x402/MPP for pay-per-request pricing.
- For an e-commerce purchase, the agent follows the ACP checkout flow, provisioning a SharedPaymentToken through Stripe.
- For API-level micropayments, the agent opens an MPP session and streams payments per GPU-minute, or pays per-request via x402.
- The payment mandate from AP2 travels with each transaction, letting the provider verify authorization.
Not every application needs all four protocols. A simple API monetization endpoint only needs x402 or MPP. A shopping agent only needs ACP. But as agent systems grow more complex — orchestrating across multiple services, mixing e-commerce with API consumption, operating across compliance boundaries — the full stack becomes relevant.
Choosing the Right Protocol
You want to monetize an API with pay-per-request pricing
Use x402 if you want fully permissionless, crypto-native settlement with zero setup for buyers. Any wallet-holding agent can pay immediately.
Use MPP if you want session-based billing, Stripe dashboard integration, and support for fiat cards alongside stablecoins. Better for high-frequency callers who benefit from pre-authorized spending limits.
You want agents to buy physical or digital goods from your store
Use ACP to define a structured checkout flow that agents can navigate programmatically. ACP keeps your existing Stripe merchant infrastructure intact and handles cart management, fulfillment options, and payment through SharedPaymentTokens.
You need to prove that an agent is authorized to spend
Use AP2 as the authorization layer on top of whatever settlement protocol you choose. AP2's Verifiable Digital Credentials provide cryptographic proof of user intent, which is essential for enterprise compliance and dispute resolution.
You want the broadest payment rail coverage
Use MPP — it's the only protocol that natively supports stablecoins, fiat cards, buy-now-pay-later, and Bitcoin Lightning on the same endpoint. x402 is stablecoin-only. ACP is fiat-only. AP2 doesn't move money.
Where the Landscape Is Heading
The agentic payments space is moving fast, but three trends are clear:
Convergence, not winner-take-all. Stripe supports both MPP and x402. Google's AP2 has an x402 extension via Coinbase. ACP's SharedPaymentTokens work within MPP sessions. The industry is building a layered stack, not picking sides. Expect more cross-protocol integrations and composite solutions.
Settlement is getting faster and cheaper. Tempo's 0.5-second finality and feeless stablecoin transfers, combined with x402's facilitator batching and L2 settlement, are driving per-transaction costs toward zero. This unlocks use cases — sub-cent micropayments, continuous payment streaming, real-time IoT transactions — that were economically impossible with traditional rails.
Authorization becomes mandatory. As agents move from demos to production, the question of "who authorized this?" becomes non-negotiable. AP2's Verifiable Digital Credentials are the leading answer, but expect payment networks, regulators, and enterprise buyers to demand increasingly formal authorization frameworks. The Wild West phase of agent payments is short.
The total addressable market is substantial. Edgar Dunn & Company estimates AI agents will drive $136 billion in consumer-to-business transaction volume in 2025, growing to $1.7 trillion by 2030. McKinsey projects agents could mediate $3–5 trillion of global consumer commerce by the end of the decade. The protocols that capture this volume are being built now.
For infrastructure builders — whether you're creating APIs, operating marketplaces, or building agent frameworks — the time to integrate is early. The agents are already spending.
Building payment infrastructure for agents and machines? Explore Openfort's backend wallets for TEE-secured signing, and see how x402 enables protocol-level payments for autonomous systems.
Related reading: