Most comparisons of x402 and the Machine Payments Protocol say the same thing: x402 is one-shot stablecoin payments with no sessions and no refunds, MPP has both. That stopped being true in May 2026. x402 now has a batch-settlement scheme with payment channels and an auth-capture scheme with void and refund operations, and the pages ranking for "x402 vs MPP" were all written in March and April, before either existed.
One of them, from a large node provider, lists MPP headers called MPP-Session and MPP-Voucher. Neither appears in the spec. So this guide works from the documents themselves: the x402 v2 specification in the x402 Foundation repo, and draft-httpauth-payment-01 plus the Tempo and Stripe method drafts for MPP, all as they stood in mid-November 2026.
What Is the Difference Between x402 and MPP?
Both protocols answer an HTTP request with 402 Payment Required, tell the client what to pay, and let it retry with proof. The difference is where each one puts the abstraction.
x402 is a payment message format with its own headers. A third party called a facilitator verifies the signed payment and submits it on-chain, so the API server never touches a private key or an RPC node. MPP is an HTTP authentication scheme. It reuses WWW-Authenticate and Authorization, the same slots Basic and Bearer use, and treats the payment rail as a pluggable "method" in the way OAuth treats grant types.
| x402 | MPP | |
|---|---|---|
| First published | May 2025 (Coinbase); v2 dated 9 Dec 2025 | 18 Mar 2026 (Stripe and Tempo) |
| Spec status | x402 Foundation under the Linux Foundation, operational 14 Jul 2026, 40 members | Individual Internet-Draft draft-httpauth-payment-01 (9 Sep 2026), no working group |
| Challenge | PAYMENT-REQUIRED header, base64 JSON | WWW-Authenticate: Payment ... |
| Proof | PAYMENT-SIGNATURE header | Authorization: Payment |
| Result | PAYMENT-RESPONSE header | Payment-Receipt header |
| Unit of variation | Scheme (exact, upto, batch-settlement, auth-capture) | Method (tempo, stripe, card, lightning) and intent (charge, session, subscription) |
| Who settles | Facilitator (/verify, /settle) | The server, through the method's own backend |
| Fiat | No | Yes, cards through Stripe Shared Payment Tokens |
x402 vs MPP Headers: What Goes on the Wire in 2026
An x402 v2 server replies with a PAYMENT-REQUIRED header. Decoded from base64, it looks like this (values illustrative, field names from the spec):
{
"x402Version": 2,
"resource": { "url": "https://api.example.com/v1/quote", "mimeType": "application/json" },
"accepts": [{
"scheme": "exact",
"network": "eip155:8453",
"amount": "10000",
"asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
"payTo": "0xMerchantAddress",
"maxTimeoutSeconds": 60,
"extra": { "assetTransferMethod": "eip3009" }
}]
}
network is a CAIP-2 identifier and amount is a string in atomic units, so "10000" is one cent of USDC. The client signs an EIP-3009 authorisation (from, to, value, validAfter, validBefore, a random 32-byte nonce) and retries with it in PAYMENT-SIGNATURE. If you still see X-PAYMENT and maxAmountRequired, you are reading v1. I covered the signature mechanics in EIP-3009 vs EIP-2612 vs Permit2.
The MPP challenge from the draft's own example:
WWW-Authenticate: Payment id="x7Tg2pLqR9mKvNwY3hBcZa",
realm="api.example.com", method="example", intent="charge",
expires="2025-01-15T12:05:00Z",
request="eyJhbW91bnQiOiIxMDAwIiwiY3VycmVuY3kiOiJ1c2QiLCJyZWNpcGllbnQiOiJhY2N0XzEyMyJ9"
request is base64url over canonical JSON and decodes to {"amount":"1000","currency":"usd","recipient":"acct_123"}. The id must be bound to the other parameters, and the draft recommends HMAC-SHA256, which lets a stateless server recognise its own challenges without a database lookup. The client echoes the challenge back inside the credential along with a method-specific payload. On success the server adds Payment-Receipt, a base64url JSON object with status, method, timestamp and reference.
There is a practical catch in MPP's choice of header. If your API already authenticates with Authorization: Bearer, the payment credential wants the same slot. A change merged on 25 August 2026 fixes this: a challenge carrying header="Payment-Authorization" moves the credential to that header and leaves Bearer alone. x402 never had the problem because it uses its own header names.
Both protocols also bind to MCP, differently. x402 returns a tool result with isError: true and reads the payment from _meta["x402/payment"]. MPP returns JSON-RPC error code -32042 and uses _meta["org.paymentauth/credential"]. An agent runtime that supports both has to recognise two unrelated "pay me" signals, a problem I went through in MCP vs A2A for payment agents.
Does x402 Support Sessions and Refunds?
Yes, on paper, and partly in production. The scheme list in the spec repo has grown well past exact:
| x402 scheme | What it does | Status |
|---|---|---|
exact | Fixed amount. EIP-3009 by default, Permit2 or ERC-7710 as alternatives; partially signed transaction on Solana | Live. Specs exist for 17 chains |
upto | Authorise a maximum, settle the actual amount, single use | Live on the Coinbase CDP facilitator |
batch-settlement | Unidirectional channel with cumulative vouchers; withdrawDelay between 15 minutes and 30 days | Live on CDP, EVM only |
auth-capture | authorize, charge, capture, void, refund, reclaim against an escrow contract | Spec only. Not on CDP's supported list |
The honest reading: exact still has no way to give money back, and the auth-capture spec says so in as many words. Refunds exist in x402 the way 3DS exists in a PSP's roadmap deck. Until a major facilitator runs auth-capture, an x402 refund is a second transfer you send yourself.
On MPP, refunds depend on the method. With the Stripe method the receipt's reference is a PaymentIntent ID and you call the ordinary Refunds API against it. Stablecoin payments through Stripe carry no dispute rights and a $10,000 per-transaction limit.
How Do MPP Sessions Work on Tempo?
A session is a payment channel. The client makes one on-chain open deposit, then sends cumulative EIP-712 vouchers to the same resource URL, each one authorising the running total rather than an increment. The credential's action field is open, topUp, voucher or close. The server settles on-chain whenever it likes, and on close the captured amount is the larger of what was spent and what was already settled.
If the server disappears, the client calls requestClose, waits out a grace period of at least 15 minutes (the draft tells clients to wait 16) and withdraws. That is the same safety valve as x402's withdrawDelay, and the two designs are closer than the marketing suggests. The operational cost is identical too: vouchers arrive faster than blocks, so every server instance needs a shared atomic store for the highest voucher seen, or two replicas will each serve work against the same balance.
Stripe's hosted version adds its own rounding. Sessions accrue from 0.000001 USDC but settle in whole cents, and the sub-cent remainder is forfeited.
x402 vs MPP Fees: What Does a Payment Cost?
| Cost | x402 | MPP |
|---|---|---|
| Protocol fee | None | None |
| Settlement service | CDP facilitator: 1,000 settlements a month free, then $0.001 each; /verify is free | Tempo method: no intermediary, the server broadcasts the transfer itself. Stripe method: £0.10 per Shared Payment Token issued (UK pricing page), plus standard card or stablecoin rates |
| Network fee | Gas on the chosen chain, paid by the facilitator | Tempo transfer capped at $0.0006, floor $0.00003, paid in a USD stablecoin |
| Minimum payment | Whatever the asset's precision allows | Stripe: $0.50 by card, 0.01 USDC by stablecoin |
Two things follow. A $0.001 facilitator fee on a one-cent call is 10%, which is why batch-settlement exists. And the card path in MPP is not a micropayment rail at all: a $0.50 floor with card pricing on top means it suits a $20 agent purchase, not a $0.005 API call. I could not find Stripe's stablecoin percentage on a page I could cite, so price that from your own dashboard.
Tempo's fee comes from its T7 upgrade on 9 July 2026, which made the base fee dynamic. Before that the same transfer cost $0.001.
What Happens When an x402 or MPP Payment Fails?
x402's default flow is authorization: verify, do the work, settle, respond. The server has already produced the resource when it calls /settle, and the response waits for chain confirmation. Since August 2026 there are two alternatives, upfront (settle first) and escrow (settle on both sides of the work). The Solana spec recommends upfront for slow handlers because a blockhash expires in 60 to 90 seconds.
Facilitator errors are a flat enum: insufficient_funds, invalid_exact_evm_payload_authorization_valid_before, invalid_exact_evm_payload_recipient_mismatch, invalid_scheme, unexpected_settle_error and about ten more. The one to design around is settlement_pending. It is non-terminal: the transaction was broadcast but not confirmed, and the response carries the hash so you can reconcile later. Treating it as a failure and re-charging is how you double-bill.
MPP returns RFC 9457 problem documents under https://paymentauth.org/problems/: payment-insufficient, payment-expired, verification-failed, method-unsupported, malformed-credential, invalid-challenge, payment-action-required and others. A structured body with a type URI is easier to route on than a string enum.
Idempotency is optional in both. x402 has a payment-identifier extension, an ID of 16 to 128 characters where the same ID with a different payload returns 409. MPP says servers "SHOULD accept an Idempotency-Key header", and the Stripe method derives its own key from the challenge ID and the token. In neither protocol can a client assume a retried request is safe. The rules from my idempotency keys guide apply unchanged.
Can One Server Accept Both x402 and MPP?
Yes, and this is the part the "versus" framing hides. MPP's documentation says the x402 exact model "maps cleanly" onto its charge intent, and the mppx SDK can emit both challenges on one 402 and accept either credential. Cloudflare's Agents SDK supports both. Stripe sells both: MPP on Tempo and Solana, x402 on Base, where its guide settles through the CDP facilitator and records a PaymentIntent with payment_method_options.crypto.mode set to transaction_verification.
Stripe is also one of the 17 premier members of the x402 Foundation, next to Visa, Mastercard, Adyen and American Express. The co-author of MPP sits on the governing body of its supposed rival.
x402 vs MPP Adoption: Which Has More Usage in 2026?
x402, by a wide margin, though every number needs a caveat. Coinbase's docs claim more than 100 million payments across Base and Solana. A Visa and Artemis analysis using data to April 2026 put adjusted volume at roughly $19 million, with about 4,000 wallets responsible for some 90% of spend, and earlier Artemis work flagged close to half of transactions as artificial. The same analysis counted about 115,000 MPP transactions worth around $25,000 in its first weeks. Stripe publishes no volume.
A probe of 458 paid endpoints in early November 2026 found 301 on x402, 121 on L402 and 36 on MPP, with median prices of $0.015 and $0.005 for x402 and MPP respectively. Of the x402 endpoints, 291 priced in USDC on Base.
Which Should You Build On?
This is opinion. I think the two converge at the wire and the real choice is which settlement backend you want to operate.
If your customers are crypto-native agents holding USDC on Base or Solana, serve x402 exact through a facilitator. It is the larger installed base, the governance is neutral, and you run no chain infrastructure. If you already have a Stripe account and want agent revenue to land in the same balance, ledger and refund tooling as everything else, serve MPP with the Stripe method and accept that you are on preview API versions.
My prediction: by the end of 2027 nobody will describe a server as "an x402 API" or "an MPP API". The 402 response will list several offers, the way a checkout lists card brands, and the IETF draft's header syntax will matter less than which facilitators and PSPs sit behind it. MPP's weak point is standing: an individual Internet-Draft with no working group is one company's design document until the IETF adopts it. x402's weak point is that its refund and session schemes are ahead of its facilitators.
What This Means for Payments Engineers
1. Emit both challenges if your SDK allows it. The marginal cost is low and you avoid betting on client wallets.
2. Pin and log the version. Record x402Version and the MPP method and intent on every payment row. v1 and v2 x402 clients are both in the wild.
3. Handle settlement_pending as a state, not an error. Store the transaction hash and reconcile against the chain before you release or re-charge.
4. Use Payment-Authorization if you already use Bearer tokens. Do not make clients choose between identity and payment.
5. Put a shared atomic store behind any session or channel endpoint. One voucher counter per channel, compare-and-set, before you scale past one replica.
6. Decide your refund path before launch. Stripe Refunds API on MPP, a manual reverse transfer on x402 exact. Write it down in your terms.
7. Do the fee arithmetic per call. Below about one cent, per-payment settlement on either protocol eats the margin and you need a channel.
Key Takeaways
- x402 is a payment format settled by a facilitator; MPP is an HTTP auth scheme with pluggable methods. Both start from a 402.
- x402 v2 uses
PAYMENT-REQUIRED,PAYMENT-SIGNATUREandPAYMENT-RESPONSE. MPP usesWWW-Authenticate: Payment,Authorization: PaymentandPayment-Receipt. - x402 gained channels (
batch-settlement) and a refund-capable scheme (auth-capture) in 2026, but only the first is live on the CDP facilitator. - MPP is the only one of the two with a fiat path, through Stripe Shared Payment Tokens, with a $0.50 card minimum.
- CDP charges $0.001 per settlement after 1,000 free a month. A Tempo transfer costs at most $0.0006.
- Stripe supports both protocols and sits on the x402 Foundation, so plan for coexistence.