Seven agentic payment protocols in 2026: a developer's guide to x402, AP2, MPP, ACP, TAP, UCP and PayPal Agent Ready logoSeven agentic payment protocols in 2026: a developer's guide to x402, AP2, MPP, ACP, TAP, UCP and PayPal Agent Ready
x402, AP2, MPP, ACP, TAP, UCP and PayPal Agent Ready get lumped together as "agent payments", but they sit at different layers. Two move money over HTTP 402, two prove who authorized what, two define a checkout, and one is a PSP adapter. Here is what each one looks like in code, what it settles on, what it costs where that is published, and how to pick.
devrels.xyz/a/397Sal listed these as six. There are seven, so we cover all seven. In June we published a map of the agentic payments landscape covering x402, AP2, MPP and L402. This piece is the code-level follow-up. It covers what each protocol actually asks you to implement, what it settles on, and what it costs where a figure has been published. Where a number isn't published, we say so.
The most useful framing still holds: these protocols aren't all competing for the same job.
- Money over HTTP 402: x402 and MPP. A server answers
402, the client pays and retries, and the server returns the resource. These are the rails for API monetization. - Proof of authorization: AP2 (signed mandates) and Visa TAP (signed agent requests). They prove who approved what. They don't move money.
- Checkout for goods: ACP and UCP. They define cart, checkout session and order APIs between an agent surface (ChatGPT, Gemini, AI Mode) and a merchant.
- PSP adapter: PayPal Agent Ready. It isn't a protocol. It wires Braintree and PayPal into ACP and UCP.
1. x402 (x402 Foundation, originally Coinbase)
Status: Coinbase contributed x402 to the Linux Foundation, which announced the x402 Foundation on 2 April 2026 and made it operational on 14 July. The Solana Foundation is a premier member. The canonical repo is now x402-foundation/x402, and coinbase/x402 is a development fork. The current spec is v2.
Flow: the client requests a resource. The server replies 402 with a base64 PaymentRequired object in the PAYMENT-REQUIRED header. The client picks one of the accepts entries, signs a payload and retries with a PAYMENT-SIGNATURE header. The server verifies and settles, either itself or through a facilitator's /verify and /settle endpoints. It then returns 200 with a PAYMENT-RESPONSE header (README flow). Schemes are exact, upto and batch-settlement.
SDK surface: TypeScript packages are @x402/core, chain packages (@x402/evm, @x402/svm, @x402/stellar and others), server middleware (@x402/express, @x402/hono, @x402/next, @x402/fastify), clients (@x402/fetch, @x402/axios) and @x402/mcp. Python is pip install x402 and Go is github.com/x402-foundation/x402/go/v2. Here's the Express seller from the seller quickstart, trimmed to the Solana route:
import express from "express";
import { paymentMiddleware, x402ResourceServer } from "@x402/express";
import { ExactSvmScheme } from "@x402/svm/exact/server";
import { HTTPFacilitatorClient } from "@x402/core/server";
const app = express();
const facilitatorClient = new HTTPFacilitatorClient({
url: "https://x402.org/facilitator", // testnet only
});
app.use(
paymentMiddleware(
{
"GET /weather": {
accepts: [
{
scheme: "exact",
price: "$0.001",
network: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1", // Solana Devnet
payTo: "YourSolanaAddress",
},
],
description: "Weather data",
mimeType: "application/json",
},
},
new x402ResourceServer(facilitatorClient)
.register("solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1", new ExactSvmScheme()),
),
);
app.get("/weather", (req, res) => res.send({ weather: "sunny" }));On Solana, the exact SVM scheme adds a feePayer to extra. The client partially signs a TransferChecked, and the sponsor co-signs as fee payer, so the buyer doesn't need SOL. The decoded accepts entry looks like this:
{
"scheme": "exact",
"network": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
"amount": "1000",
"asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
"payTo": "2wKupLR9q6wXYppw8Gr2NvWxKBUqm4PPJKkQfoxHDBg4",
"maxTimeoutSeconds": 60,
"extra": {
"feePayer": "EwWqGE4ZFKLofuestmU4LDdK7XM1N4ALgdZccwYugwGd",
"memo": "pi_3abc123def456"
}
}On the client side, @x402/fetch wraps fetch with wrapFetchWithPaymentFromConfig(fetch, { schemes }) and retries 402s automatically (README).
- Chains and tokens: networks are CAIP-2 IDs. The network docs list any EVM chain (via EIP-3009 or Permit2), Solana ("any SPL or Token-2022 token"), TON, Algorand, Stellar, Aptos, Hedera, Keeta, NEAR, Concordium, XRPL, Cardano, Sui and Canton.
batch-settlementruns on EVM and SVM, using the Solana Foundation's payment-channels program on Solana. Fiat is allowed by the spec (anassetcan be an ISO 4217 code), but every production route we found is stablecoins. - Fees: the protocol has no fee. You pay network gas, plus a facilitator fee if your facilitator charges one. Coinbase's CDP Facilitator gives you 1,000 free onchain transactions a month, then charges $0.001 per onchain transaction. Verification is free. On Solana it supports
exactandupto. Among the listed facilitators that cover Solana, Dexter describes itself as free with no fees, and PayAI says no API keys are required (see our PayAI piece). The publicx402.orgfacilitator is testnet only. - Latency: the x402 FAQ claims settlement in "~1 second". In practice, latency is your chain's confirmation time plus the facilitator round trip. The facilitator client's default HTTP timeout is 90 seconds.
- Trust model: bearer-style. Whoever holds the key pays, and there's no user consent object. The spec requires that a facilitator can't move funds beyond what the client signed. On Solana, the SVM packages ship a
SettlementCachebecause duplicate submissions can come back as "success". Use a production facilitator, or keep that cache if you self-facilitate (facilitator docs).
2. Google AP2 (Agent Payments Protocol)
Status: google-agentic-commerce/AP2, Apache 2.0. v0.1.0 shipped in September 2025, and v0.2.0 shipped on 28 April 2026. There's no published PyPI package yet. The README says to install from git.
An important update on mandate names: you'll still see "Intent, Cart and Payment Mandates" everywhere. That's the v0.1 model. The v0.2 spec defines two mandate types: a Checkout Mandate (what is being bought, bound by hash to a merchant-signed checkout JWT) and a Payment Mandate (authority to pay for that checkout). Each has an open variant with constraints, which covers the old Intent Mandate's job in "Human Not Present" mode. Mandates are SD-JWTs, versioned through the vct claim.
Flow: a Shopping Agent builds the checkout. A Trusted Surface gets the user's consent and signs the mandates. The Merchant verifies the Checkout Mandate. The Credential Provider and the Merchant Payment Processor verify the Payment Mandate, then signed receipts come back. AP2 explicitly says it "operates as a security feature within a Commerce Protocol" and is designed to work with UCP. Here's the payload shape from payment_mandate.json (illustrative values, before SD-JWT wrapping):
{
"vct": "mandate.payment.1",
"transaction_id": "<base64url sha-256 of the merchant-signed checkout_jwt>",
"payee": { "id": "merchant_1", "name": "Demo Merchant", "website": "https://merchant.example" },
"payment_amount": { "amount": 27999, "currency": "USD" },
"payment_instrument": { "id": "card_abc", "type": "card", "description": "Visa •••• 4242" },
"iat": 1763510400,
"exp": 1763514000
}Open mandates carry constraints such as payment.allowed_payees, payment.agent_recurrence (for example, monthly, at most 12 times) and payment.execution_date windows (payment_mandate.md).
- Rails: payment-instrument agnostic. Amounts are ISO 4217 minor units. For crypto, the FAQ points to a2a-x402 for x402 alongside A2A. We found no Solana-specific instrument type in the AP2 schemas.
- Fees and latency: not published. AP2 adds signing and verification, and the PSP you settle through sets the cost.
- Trust model: the strongest of the seven on consent. You get user-signed, non-repudiable evidence of what was approved, which is designed for dispute resolution.
3. MPP (Machine Payments Protocol, Tempo + Stripe)
Status: co-authored by Tempo and Stripe. The core is an IETF Internet-Draft, draft-httpauth-payment, which is a draft and not yet an RFC. Docs live at mpp.dev. The TypeScript SDK is mppx, with Rust (mpp-rs), Python (pympp), Go (mpp-go) and Ruby (stripe/mpp-rb) SDKs too.
Flow: MPP builds on HTTP authentication. The server replies 402 with WWW-Authenticate: Payment, carrying id, realm, method, intent and request parameters. The client retries with Authorization: Payment, and the server returns a Payment-Receipt. Errors use RFC 9457 problem details (HTTP 402 docs). Intents are charge, session (metered, with off-chain vouchers) and subscription on Tempo.
HTTP/1.1 402 Payment Required
WWW-Authenticate: Payment id="abc123",
realm="mpp.dev",
method="tempo",
intent="charge",
request="eyJ..."Charging for an endpoint with the Solana method, which is maintained by the Solana Foundation as @solana/mpp:
// npm install @solana/mpp mppx @solana/kit
import { Mppx } from "mppx/server";
import { solana } from "@solana/mpp/server";
const mppx = Mppx.create({
methods: [
solana.charge({
recipient: "9xAXssX9j7vuK99c7cFwqbixzL3bFrzPy9PUhCtDPAYJ",
currency: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
decimals: 6,
network: "localnet",
}),
],
secretKey: process.env.MPP_SECRET_KEY!, // openssl rand -hex 32
});
// Client side: Mppx.create({ methods: [solana.charge()] }) from "@solana/mpp/client"
// patches fetch so 402s are paid and retried automatically.- Rails: per the payment methods table, Tempo, Stripe (cards via Shared Payment Tokens, plus stablecoins), Card (
mpp-card, maintained by Visa, using encrypted network tokens) and Lightning are marked "Production". EVM, Solana (charge and session), XRPL, Stellar, Monad, NEAR Intents and RedotPay are marked "Available", which means the SDK has been published and you should ask the maintainer about production readiness. Stripe's machine payments docs list MPP on Tempo (USDC.e) and on Solana (USDC), plus x402 on Base (USDC). Stripe stablecoin acceptance is limited to US businesses outside New York unless you request wider access. - Fees: the protocol is free. Through Stripe, the minimum is $0.50 for card SPTs and 0.01 USDC for stablecoins. Stripe's pricing page lists stablecoin payments at 1.5% of the USD amount and cards at 2.9% + 30¢ for domestic cards. Stripe says Tempo network fees are "typically less than USD 0.001".
- Latency: no number is published for
charge, which costs one onchain transaction per request. The MPP FAQ describessessionas having "near-zero latency and per-request fees" because vouchers are signed off-chain and only net settlement hits the chain. - Trust model: challenges are bound to the server with
MPP_SECRET_KEY. There's replay protection through a sharedstore, which is required in production, plus request-body digest binding. MPP and x402 can interoperate:mppxcan serve x402exactEVM clients on the same route (FAQ).
For a settlement-layer comparison, see Tempo vs Solana for payments.
4. ACP (Agentic Commerce Protocol, OpenAI + Stripe)
Status: agentic-commerce-protocol, Apache 2.0, maintained by OpenAI and Stripe, and marked beta. Versions are dated. The latest stable is 2026-04-17, which adds cart, feeds, orders, authentication and MCP.
The surface matters as much as the spec. OpenAI's merchant page now says it is "moving away from a standalone Instant Checkout experience in ChatGPT", and purchases complete on merchant-owned sites or apps. Today ACP in ChatGPT mainly powers product discovery through feeds. Custom ChatGPT apps can still run ACP checkout, as PayPal's guide below shows.
Flow: the merchant implements REST endpoints. POST /checkout_sessions creates a session. POST /checkout_sessions/{id} updates it. POST /checkout_sessions/{id}/complete pays, and /cancel cancels. The agent shows the cart, the user approves it in the agent UI (that's the human-in-the-loop step), and the PSP mints a scoped token through POST /agentic_commerce/delegate_payment. Required headers are Authorization: Bearer, Idempotency-Key on every POST and API-Version. Signature and Timestamp are optional (OpenAPI).
curl -X POST https://merchant.example.com/checkout_sessions/cs_123/complete \
-H "Authorization: Bearer $AGENT_API_KEY" \
-H "Idempotency-Key: 550e8400-e29b-41d4-a716-446655440000" \
-H "API-Version: 2026-04-17" \
-H "Content-Type: application/json" \
-d '{
"buyer": { "first_name": "John", "last_name": "Smith", "email": "[email protected]" },
"payment_data": { "token": "spt_123", "provider": "stripe" }
}'The delegated token carries an allowance: reason: "one_time" (currently the only value), max_amount, currency, checkout_session_id, merchant_id and expires_at (delegate_payment spec).
- Rails: the delegate payment spec says "exactly one credential type is currently supported: card". No chain or stablecoin path is specified in ACP. On Stripe, the token is a Shared Payment Token (
spt_). - Fees: OpenAI's merchant page says there are "no fees on purchases that start in ChatGPT". Card processing fees still apply. Earlier reports of a 4% Instant Checkout fee came through a Shopify spokesperson, and OpenAI never published that rate. Latency figures aren't published.
- Trust model: the user approves the cart in the agent UI. The token is single-use and bounded by amount, merchant, session and expiry. The merchant stays merchant of record.
5. Visa Trusted Agent Protocol (TAP)
Status: a spec on developer.visa.com with no version number, plus a Python and Node sample in visa/trusted-agent-protocol (an agent, a CDN proxy verifier, an agent key registry and a demo merchant). It's an identity layer, not a payment rail.
Flow: the agent signs every request to the merchant with RFC 9421 HTTP Message Signatures, covering @authority and @path. The tag is agent-browser-auth for browsing or agent-payer-auth at checkout. The merchant, or more often its CDN, verifies the signature against Visa's published key for that keyid. At checkout, signed agenticConsumer and agenticPaymentContainer body objects can carry consented identifiers such as a Payment Account Reference.
GET /checkout HTTP/1.1
Host: www.example.com
Signature-Input: sig2=("@authority" "@path"); created=1735689600; expires=1735693200;
keyid="poqkLGiymh_W0uP6PZFw-dvez3QJT5SolqXBCW38r0U"; alg="Ed25519";
nonce="e8N7S2MFd/qrd6T2R3tdfAuuANngKI7LF..."; tag="agent-payer-auth"
Signature: sig2=:jdq0SqOwHdyHr9+r5jw3iYZH6aNGKijYp/EstF4RQTQ...:- Verification rules from the spec: reject the request if any required field is missing, if
createdandexpiresare more than 8 minutes apart or outside the current time, or if the nonce was seen in the last 8 minutes. The sample supports Ed25519 and RSA-PSS-SHA256. - Rails: TAP itself carries no money. Payment uses Visa cards and network tokens, for example through Visa Intelligent Commerce. Visa also maintains MPP's
cardmethod. TAP has no chain or token support. - Fees and latency: none published for TAP. The cost is one signature check per request, and card economics apply to the payment.
- Trust model: it proves the request came from a recognised agent and is bound to this domain and path. It doesn't carry user consent or spending limits, which is AP2's job.
6. UCP (Universal Commerce Protocol, Google + Shopify)
Status: Universal-Commerce-Protocol/ucp, Apache 2.0. Shopify describes it as "co-developed by Shopify and Google". The current spec version is 2026-08-25 (spec overview). Per Google Merchant Center, UCP-powered checkout on AI Mode and Gemini is for select merchants and for products eligible in the US, Canada and Australia.
Flow: the business publishes a profile at /.well-known/ucp listing services, capabilities (dev.ucp.shopping.checkout, identity linking, order) and payment handlers. The platform (the agent) sends its own profile URL in a UCP-Agent header, both sides negotiate the capability intersection, and the agent calls POST {endpoint}/checkout-sessions. Transports are REST, MCP and A2A. Signing keys sit in the profile's keys[] JWK Set, which is reusable for Web Bot Auth.
// GET https://business.example.com/.well-known/ucp (trimmed)
{
"ucp": {
"version": "2026-08-25",
"services": {
"dev.ucp.shopping": [{
"version": "2026-08-25",
"transport": "rest",
"endpoint": "https://business.example.com/ucp/v1",
"schema": "https://ucp.dev/2026-08-25/services/shopping/rest.openapi.json"
}]
},
"payment_handlers": {
"com.google.pay": [{ "id": "gpay_1234", "version": "2024-12-03" }],
"dev.shopify.shop_pay": [{ "id": "shop_pay_1234", "version": "2026-08-25" }]
}
}
}- Rails: whatever your payment handlers expose. The spec examples are Google Pay and Shop Pay, and there's an
dev.ucp.common.payment.ap2_mandateextension for autonomous agents. We found no stablecoin or chain-specific handler in the spec overview. A handler is an extension point, so one could be added, but none is published today. - Fees and latency: no UCP-specific fee or latency figure is published in the docs we read. Your PSP's processing fees apply.
- Trust model: capability negotiation plus HTTP Message Signatures, OAuth 2.0 identity linking, and AP2 mandates when no human is present. Credentials flow one way, platform to business, to keep PCI scope down.
7. PayPal Agent Ready
Status: Agent Ready overview (updated 13 October 2026). PayPal's own ai-toolkit notes call agentic commerce "early-access", and you request access through a form. It isn't a new wire protocol. It's PayPal's implementation of ACP and UCP for Braintree and PayPal merchants.
- ACP path (ChatGPT): you build a ChatGPT app with the Apps SDK and an MCP server that exposes a
complete_checkouttool. The app callsrequestCheckout()withbraintreeas the provider. The delegated token is then used like any Braintree nonce intransaction.saleor thechargePaymentMethodGraphQL mutation (ACP guide). - UCP paths (AI Mode, Gemini): a Google Pay payment handler, either through Braintree or through PayPal's Orders v2 API, which decrypts the Google Pay credential that Google sends in the checkout session.
- Rails:
card,applepayandgooglepayper the ai-toolkit notes. No chain or stablecoin path is documented for Agent Ready. - Fees and latency: no separate Agent Ready fee is published. You use your existing Braintree or PayPal processing relationship.
- Trust model: the one-time token is bound to your merchant ID, a max amount, a currency and an expiry, and ChatGPT transactions are tagged with
facilitator_details.
Comparison table
| Protocol | Layer | Wire surface | Rails | Solana | Published cost | Status |
|---|---|---|---|---|---|---|
| x402 | Settlement over HTTP | 402 + PAYMENT-REQUIRED / PAYMENT-SIGNATURE | Stablecoins and tokens on EVM, Solana and 12+ other networks | Yes: any SPL or Token-2022 token, gasless via feePayer | Gas, plus facilitator fee (CDP: 1,000/month free, then $0.001 per tx) | v2, Linux Foundation |
| MPP | Settlement over HTTP | 402 + WWW-Authenticate: Payment | Tempo, cards (Stripe SPT, Visa), Lightning, Solana and more | Yes: @solana/mpp, charge and session; Stripe lists Solana USDC | Protocol free; Stripe 1.5% stablecoin, 2.9% + 30¢ card | IETF draft |
| AP2 | Authorization evidence | SD-JWT Checkout and Payment Mandates | Instrument-agnostic | Not specified (x402 via a2a-x402) | Not published | v0.2 |
| TAP | Agent identity | RFC 9421 Signature-Input / Signature | None (Visa cards downstream) | No | Not published | Unversioned spec + sample |
| ACP | Checkout | /checkout_sessions, /agentic_commerce/delegate_payment | Card only (delegated token) | No | OpenAI: no fee on purchases starting in ChatGPT; card processing applies | Beta, 2026-04-17 |
| UCP | Commerce + checkout | /.well-known/ucp, UCP-Agent, /checkout-sessions | Payment handlers (Google Pay, Shop Pay, AP2) | No published handler | Not published (PSP fees apply) | 2026-08-25, select merchants |
| PayPal Agent Ready | PSP adapter | ACP + UCP via Braintree / Orders v2 | Card, Apple Pay, Google Pay | No | Existing PayPal/Braintree pricing | Early access |
How to choose a rail
You're monetizing an API, MCP server or data feed
Use x402 or MPP. Both are a middleware line on your server and a wrapped fetch on the client, with no accounts and no API keys. Things to check:
- Who your buyers are. If agents hold Solana USDC, both protocols take it. x402 has the larger facilitator ecosystem on Solana, and MPP has a Solana Foundation-maintained method. If some buyers only have cards, MPP's Stripe and Card methods cover that, but note the $0.50 card minimum on Stripe.
- Price per call. Sub-cent, high-frequency pricing (per token or per row) wants channels rather than one transaction per request: MPP
session, or x402uptoorbatch-settlement. On Stripe-settled MPP sessions, sub-cent remainders are forfeited at settlement, so make your settlement amount a whole number of cents. - Who runs settlement. With x402, you pick a facilitator or self-facilitate. With MPP on Stripe, funds land in your Stripe balance in fiat, with Stripe's reporting and refunds, but you pay Stripe's percentage.
- You don't have to pick only one.
mppxcan answer x402exactEVM clients on the same route, and x402 lets one route list multiple networks inaccepts.
Solana-specific starting points: build an x402 seller on Solana, Cloudflare's monetization gateway, the Solana Foundation pay CLI, and a live example in Milypay's Australian x402 data APIs.
Your agent buys physical goods for users
This is card commerce, and checkout protocols plus the PSP do the heavy lifting. Merchants who want to appear in Gemini or AI Mode should implement UCP. Merchants who want to appear in ChatGPT should implement ACP feeds and, if they build an app, ACP checkout. PayPal Agent Ready or Stripe can implement either for you. If you're building the agent, add AP2 mandates when the user isn't present, so you have signed evidence of what they authorized. Sign your traffic with TAP, or Web Bot Auth through your CDN, so merchant bot defences don't block you.
Questions to answer before you commit
- Is there a human in the loop at payment time? If yes, ACP or UCP checkout with in-agent approval works. If not, you need pre-authorized limits: AP2 open mandates, x402 or MPP with a budget-capped wallet, or MPP sessions.
- Who carries chargeback risk? Card rails (ACP, UCP, TAP, PayPal) come with dispute infrastructure. Stablecoin rails settle finally, so refunds are your own logic (MPP has a refunds extension).
- Where are you allowed to sell? Stripe stablecoin acceptance has geographic limits. UCP checkout is limited to select merchants in the US, Canada and Australia. ChatGPT shopping is live in the US.
- How stable is the spec? ACP is beta, AP2 is v0.2 with a recent mandate rename, MPP's core is an IETF draft, and PayPal Agent Ready is early access. Pin versions with ACP's
API-Version, AP2'svctsuffix and UCP's datedversion, and plan for breaking changes.
What we couldn't verify
- No per-protocol latency benchmarks are published by any of the seven. x402's "~1 second" and MPP's "near-zero" session latency are their own claims.
- AP2, TAP and UCP publish no fees, because they don't move money. PayPal publishes no Agent Ready-specific fee.
- OpenAI's former Instant Checkout fee was reported (4%, via Shopify) and never published by OpenAI. The current page says there are no fees on purchases that start in ChatGPT.
- MPP's Solana method is listed as "Available", not "Production", on mpp.dev, even though Stripe lists MPP on Solana USDC as a supported network.
Sources: the official specs, repos and docs linked inline, all read on 19 November 2026.
Keep reading
pay is a Rust CLI that acts as a transparent HTTP payment proxy. When any tool behind it hits a 402, pay detects whether it's x402 or MPP, prepares a USDC transaction, asks your local wallet (Touch ID on macOS) to sign it, then retries. Agents pay for APIs. You stay in control.
Mastercard's Agent Pay for Machines puts the incumbent into agentic payments — but the interesting part isn't the card network, it's where the authorization lives. Agent permissions and credentials are written to public blockchains (Solana among the first three) as a 'Verifiable Intent' ledger anyone can audit, while settlement stays on Mastercard's network. A look at the architecture and how it sits beside x402.
Everyone's racing to be the payment layer for AI agents, and the names blur together: x402, AP2, MPP, L402. They're not all competitors — some are settlement rails, one is an authorization layer, one is for humans at a checkout. Here's the map, what each is actually for, and why Solana ends up at the center of the settlement story.
Get new articles in your inbox
Technical deep-dives on Solana tooling, infrastructure, and ecosystem. No noise.
