Stripe and Tempo's Machine Payments Protocol (MPP) is an open HTTP-native standard for billing AI agents that ships agent-payment primitives past one-shot calls into recurring subscriptions, streaming usage, cancellation, and reconciliation. Stripe and Tempo released MPP on March 18, 2026, the same day Tempo's payments-focused L1 went to mainnet, and extended it with a streaming-payments primitive at Sessions 2026 on April 29-30, 2026. MPP shares its signature substrate with Coinbase's x402 protocol, leaning on EIP-3009 and Permit2 for off-chain authorization, while adding the lifecycle machinery that pure HTTP 402 leaves on the table.
​

The Machine Payments Protocol (MPP) is Stripe and Tempo's open standard for billing AI agents over HTTP. It defines how agents discover prices, request payment, authorize charges, manage subscriptions, and reconcile balances across stablecoins, cards, and BNPL. Funds settle through Stripe PaymentIntents, with Tempo as the default stablecoin chain.
​

MPP shipped on March 18, 2026 through a co-authored announcement at stripe.com/blog/machine-payments-protocol. Stripe and Tempo positioned it as the agent-billing equivalent of what Stripe's PaymentIntents did for human checkout: a single API surface that abstracts payment method, network, and lifecycle. Where x402 handles a one-shot HTTP 402 handshake, MPP wraps that handshake in a multi-method, lifecycle-aware envelope.
​

The protocol is HTTP-native. An agent makes a request. The service responds with an MPP-shaped payment requirement that lists the price, the accepted methods, the cadence (one-shot, recurring, streaming), and the metadata. The agent authorizes payment using whichever method the service supports. Funds settle through PaymentIntents and surface in the merchant's normal Stripe Dashboard, with the same fraud signals, tax handling, and reporting as a card payment.
​

Three things separate MPP from a simple HTTP 402 call. First, it is multi-method: stablecoins through x402, cards through Shared Payment Tokens, and BNPL through Klarna or Affirm all flow through the same wire shape. Second, it is lifecycle-aware: subscriptions, streaming charges, cancellations, and balance reconciliation are first-class primitives. Third, it has Stripe's existing merchant rails behind it, so an agent-billing endpoint inherits Stripe's fraud, dispute, and accounting machinery without separate plumbing. Tempo is the second author and the default stablecoin chain; the Tempo mainnet launch on the same day was timed deliberately.
​

An agent calls a service; the service returns a payment requirement; the agent authorizes via x402, SPT, or BNPL; Stripe issues a PaymentIntent and the funds settle. MPP layers four primitives on top of that handshake: recurring subscriptions, streaming payments, cancellation events, and balance reconciliation, all addressed over the same HTTP surface.
​

The core handshake mirrors x402's payment-required pattern. An agent issues an HTTP request to a paid endpoint. The service replies with a 402 (or MPP-shaped equivalent) carrying a JSON payment requirement. That payload describes the price, the accepted methods, the resource scope, and the cadence. The agent constructs an authorization, signs it, and resends the request with the signature attached. The service verifies through a Stripe-side facilitator and returns the resource.
​

What MPP adds is lifecycle. Four primitives matter:

The recurring and streaming primitives push agent payments past the one-shot ticket regime that x402 alone covers. A typical x402 charge is sub-cent (CoinGecko's x402 endpoint bills $0.01 USDC per request); a typical MPP-streaming charge could be a fraction of a cent per LLM token, summed over a multi-hour agent task. The protocol-level cadence shifts what the developer surface optimizes for, from per-request finality to per-window finality.
​

The lifecycle events map to typed payloads that both sides can verify. A subscription event carries the cadence, the next charge timestamp, and the cumulative authorized window. A streaming event carries the rate, the unit (per token, per second, per call), and the checkpoint cadence. A cancellation event carries the reason code and the refund amount, if any. A reconciliation query returns a structured ledger view scoped to the agent-service pair. Because each event is a typed object with a fixed schema, an agent operating across multiple MPP services can reason about its own state programmatically rather than scraping invoices.
​

MPP and x402 share a signature substrate: EIP-3009 for native USDC authorizations and Permit2 for ERC-20 tokens that lack 3009 directly. Both standards let an agent authorize a transfer off-chain through a typed signature. The service submits the signature on-chain to settle. No separate approval transaction is required, and the agent never holds gas.
​

EIP-3009 was finalized in 2020 and ships natively in USDC, USDP, and a handful of other Centre-issued stablecoins. The standard adds three functions to the ERC-20 contract: transferWithAuthorization, receiveWithAuthorization, and cancelAuthorization. An agent signs an EIP-712 typed payload that authorizes a specific recipient, amount, validity window, and nonce. The service receives the signature, calls the authorization function on the USDC contract, and the transfer executes in one atomic step. Crucially, the agent never holds gas on the destination chain; the service pays gas to settle. That economic asymmetry is what makes one-shot agent payments viable.
​

The validity-window field on the typed payload is what unlocks subscription and streaming primitives. A signature with a 30-day window can be submitted multiple times during that window for distinct nonce values, which lets a service charge a recurring subscription against the same authorization without forcing the agent to re-sign per cycle. The cancellation event in MPP maps directly to the on-chain cancelAuthorization function, so a cancelled subscription invalidates the signature on the chain itself, not just in Stripe's records. The wire-level event and the contract-level state stay consistent.
​

Permit2 covers the long tail. Most ERC-20 tokens were deployed before EIP-3009 existed and lack the typed-authorization functions natively. Uniswap's Permit2 contract is a single trusted intermediary that supports off-chain signature authorization for any standard ERC-20. The agent grants Permit2 a one-time approval, then signs typed payloads that authorize specific transfers from its balance through Permit2. The service-side flow is the same: receive signature, submit on-chain, settle. Permit2 has been deployed on every major EVM chain (Ethereum, Base, Polygon, Arbitrum, Optimism, BNB Chain, Avalanche) and processes signatures across them with a common interface.
​

For agents holding non-USDC stablecoins like USDT, USDe, PYUSD, or GHO, Permit2 is the only path to gasless authorization today. USDT in particular ($189.5B in circulation per DeFiLlama) does not natively support EIP-3009, so any MPP integration that wants to bill an agent paying in USDT relies on Permit2 to mediate the signature flow. The substrate choice is the difference between an MPP service that can accept the long tail of stablecoins and one that is USDC-only.
​

Stripe's x402 documentation requires the 2026-03-04.preview API version and lists three USDC contracts at launch: Base (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913), Solana (EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v), and Tempo. The shared signature substrate means an MPP integration that already supports x402 inherits the same off-chain authorization flow for subscription and streaming charges. The semantics carry across; only the cadence and the lifecycle envelope differ.
​

Two design choices follow from the substrate. First, MPP's per-token, per-second streaming is feasible only because the signature flow is gasless on the agent side; an agent paying gas per millisecond would be uneconomic. Second, the same signature primitive that authorizes a one-shot $0.01 charge can authorize a $1,000 monthly subscription, because the typed payload encodes the amount and validity window explicitly. The protocol leans on cryptography to do what traditional payments use bank-side mandates for.
​

MPP went live with Tempo mainnet on March 18, 2026, supporting USDC settlement on the new payments-focused L1. At Sessions 2026 (Apr 29-30, 2026, with 9,000-plus attendees and 288 product launches), Stripe added streaming payments as a first-class MPP primitive, designed to bill AI products in real time against a stablecoin balance.
​

Tempo is a payments-focused L1 blockchain that Stripe led the funding for and that went live in March 2026. The chain is purpose-built for stablecoin settlement and agent-payment workloads, with EVM compatibility and a fee structure tuned for sub-cent ticket sizes. USDC on Tempo is one of the three USDC contracts Stripe lists in its x402 docs alongside Base and Solana, and it is the default chain for MPP's streaming primitive.
​

The streaming-payments extension at Sessions 2026 is the larger structural shift. Stripe announced 288 products and updates over two days at Moscone West with 9,000-plus attendees in attendance. Among them: a Tempo-settled streaming primitive that lets a service bill against token-level usage on AI products in real time, with the agent's USDC balance debited continuously rather than in lump-sum invoices. The Sessions 2026 recap framed Tempo as the chain where this happens; the streaming primitive is the wire-level mechanism that sits on top.
​

The strategic point of streaming is that LLM-based agent tasks have a usage shape no prior payment rail addressed. A multi-hour agent run might consume API calls across half a dozen services, each priced per-token. Settling each call as a separate x402 charge multiplies signature overhead; settling them all at task completion forces the service to extend credit. Streaming MPP runs a continuous debit against a prepaid balance, with finality checkpoints so neither side carries open exposure for long. Stripe and Tempo are betting that this is the cadence agent-payment volume actually grows into.
​

Two production touchpoints worth tracking. First, the Stripe Machine Payments docs as of late April 2026 list MPP as live with x402 and SPT as accepted methods, while flagging recurring and streaming primitives as still rolling out across the developer surface. Second, Tempo's mainnet ledger is publicly queryable; teams integrating MPP can verify settlement against the chain itself rather than trusting Stripe's Dashboard alone. The combination of Stripe's merchant rails and an open settlement chain is what gives MPP a different trust shape than a pure proprietary API.
​

The launch sequencing is worth reconstructing. Coinbase published the original x402 protocol on May 6, 2025. Stripe and OpenAI shipped ACP on September 29, 2025, alongside ChatGPT Instant Checkout. Stripe added x402 support on February 10, 2026, with USDC on Base and a US-business-only restriction reported by The Block. MPP and Tempo mainnet shipped together on March 18, 2026. ChatGPT Instant Checkout was retired on March 24, 2026. The Link Agent Wallet and the MPP streaming primitive both arrived at Sessions 2026 on April 29, 2026. Six product launches in nine months, all converging on the same agent-payment surface.
​

For developers, the production checklist is shorter than the launch sequence suggests. An MPP integration needs a Stripe account, the 2026-03-04.preview API version, a PaymentIntents flow on the backend, and middleware that emits MPP-shaped 402 responses. The accepted methods are configured per endpoint; a service can opt into x402-only, SPT-only, or both. Streaming and recurring require additional configuration around the cadence and checkpoint policy. The x402 docs include sample integrations for Node.js (using the @x402/hono middleware) and Python that map cleanly onto MPP once the lifecycle wrapper is in place.
​

x402 is the wire format for one-shot HTTP 402 stablecoin handshakes; ACP is Stripe and OpenAI's consumer-side checkout protocol with Shared Payment Tokens; MPP is the multi-method, lifecycle-aware envelope that wraps both for agent billing. x402 is HTTP-native and stablecoin-only; ACP is card-rail-shaped and consumer-focused; MPP spans both with subscription and streaming primitives.
​

The three protocols solve adjacent problems and overlap at the edges. The table below summarizes the differences.

Choosing among them depends on the shape of the payment workload. For agent-to-agent micropayments where neither party is a registered Stripe merchant, x402 alone is the simplest path: roughly 50 lines of HTTP middleware on the server, no merchant onboarding, settlement direct on-chain. The CoinGecko x402 endpoint is the canonical example. For consumer-driven agent checkout where a person is in the loop and the funding source is a card, ACP plus a Shared Payment Token through the Link Agent Wallet is the path; this is what powered ChatGPT Instant Checkout until OpenAI retired it on March 24, 2026.
​

For agent-to-business billing where the service runs Stripe and the agent might pay in any of stablecoins, cards, or BNPL, MPP is the right shape. It abstracts the payment method behind one wire format, adds the subscription and streaming primitives that pure x402 lacks, and inherits Stripe's existing merchant tooling. The trade-off is integration depth: MPP requires a Stripe account, a PaymentIntents integration, and standard merchant onboarding, while x402 alone runs without any of that.
​

The deeper architectural point is that MPP is not a replacement for x402. x402 is an accepted method inside MPP, the way USDC is an accepted token inside the broader stablecoin universe. A service running MPP on its API can accept USDC over x402 from agents that hold stablecoin balances, accept SPT-backed cards from agents tied to a corporate Link Agent Wallet, and bill recurring or streaming charges across both. The same Stripe Dashboard reports the lot. For a fuller protocol-by-protocol comparison covering ACP, AP2, MPP, x402, and the Universal Commerce Protocol, see the agent payment protocols comparison.
​

One more practical note. Because MPP and x402 share the EIP-3009 and Permit2 substrate, an existing x402 client implementation ports to MPP with a thin upgrade. The signature flow stays the same; the wire envelope changes from a 402-only handshake to an MPP-shaped 402 plus lifecycle event types. Agent frameworks like LangChain, AutoGen, and OpenAI's Agents SDK that already speak x402 inherit the substrate. The integration cost for an existing x402-aware agent is closer to a configuration change than a rewrite, which is part of why Stripe and Tempo positioned MPP as a layer up rather than a competing protocol.
​

Stripe MPP settles in USDC on Tempo, Base, or Solana. Eco extends that surface to the 12 other chains where agent treasuries actually live. Stripe handles fiat plus the three native MPP chains. Eco's stablecoin execution network handles routing, solver selection, and finality so an agent on Arbitrum, Polygon, or Tron can settle into an MPP endpoint without writing the bridging logic.
​

MPP's stablecoin settlement runs on three chains today. That covers a meaningful slice of agent-payment volume, but agent treasuries do not always live on those three. Stablecoin supply across the broader market is roughly $318 billion (per DeFiLlama, late April 2026), with USDT at $189.5 billion and USDC at $77.3 billion, and meaningful stablecoin TVL sits on chains like Tron, Arbitrum, Polygon, BSC, and Avalanche that are outside MPP's native settlement set. Eco operates as a stablecoin execution network across 15 chains, abstracting routing, solver selection, and finality through Hyperlane messaging and Circle's CCTP transport. An agent billing through MPP from a treasury on Solana to a service settling on Tempo can hand the cross-chain leg to Eco without touching a bridge or a swap aggregator directly. Stripe handles the agent-payment surface; Eco handles the multi-chain reality behind it.
​

Sources and methodology. MPP details verified against the March 18, 2026 Stripe announcement and the Sessions 2026 recap. EIP-3009 spec from eips.ethereum.org; Permit2 from the Uniswap GitHub. Stablecoin supplies pulled from DeFiLlama on April 29, 2026. Figures refresh quarterly.
​