← Articles
Seven agentic payment protocols in 2026: a developer's guide to x402, AP2, MPP, ACP, TAP, UCP and PayPal Agent Ready logo
solana

Seven agentic payment protocols in 2026: a developer's guide to x402, AP2, MPP, ACP, TAP, UCP and PayPal Agent Ready

· NOV 19, 2026 ·
Read
Share

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/397

Sal 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:

typescript
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:

json
{
  "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-settlement runs on EVM and SVM, using the Solana Foundation's payment-channels program on Solana. Fiat is allowed by the spec (an asset can 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 exact and upto. 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 public x402.org facilitator 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 SettlementCache because 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):

json
{
  "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.

text
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:

typescript
// 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 describes session as 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 shared store, which is required in production, plus request-body digest binding. MPP and x402 can interoperate: mppx can serve x402 exact EVM 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).

bash
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": "johnsmith@mail.com" },
    "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.

text
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 created and expires are 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 card method. 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.

json
// 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_mandate extension 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_checkout tool. The app calls requestCheckout() with braintree as the provider. The delegated token is then used like any Braintree nonce in transaction.sale or the chargePaymentMethod GraphQL 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, applepay and googlepay per 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

Seven agentic payment protocols, November 2026
ProtocolLayerWire surfaceRailsSolanaPublished costStatus
x402Settlement over HTTP402 + PAYMENT-REQUIRED / PAYMENT-SIGNATUREStablecoins and tokens on EVM, Solana and 12+ other networksYes: any SPL or Token-2022 token, gasless via feePayerGas, plus facilitator fee (CDP: 1,000/month free, then $0.001 per tx)v2, Linux Foundation
MPPSettlement over HTTP402 + WWW-Authenticate: PaymentTempo, cards (Stripe SPT, Visa), Lightning, Solana and moreYes: @solana/mpp, charge and session; Stripe lists Solana USDCProtocol free; Stripe 1.5% stablecoin, 2.9% + 30¢ cardIETF draft
AP2Authorization evidenceSD-JWT Checkout and Payment MandatesInstrument-agnosticNot specified (x402 via a2a-x402)Not publishedv0.2
TAPAgent identityRFC 9421 Signature-Input / SignatureNone (Visa cards downstream)NoNot publishedUnversioned spec + sample
ACPCheckout/checkout_sessions, /agentic_commerce/delegate_paymentCard only (delegated token)NoOpenAI: no fee on purchases starting in ChatGPT; card processing appliesBeta, 2026-04-17
UCPCommerce + checkout/.well-known/ucp, UCP-Agent, /checkout-sessionsPayment handlers (Google Pay, Shop Pay, AP2)No published handlerNot published (PSP fees apply)2026-08-25, select merchants
PayPal Agent ReadyPSP adapterACP + UCP via Braintree / Orders v2Card, Apple Pay, Google PayNoExisting PayPal/Braintree pricingEarly 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 x402 upto or batch-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. mppx can answer x402 exact EVM clients on the same route, and x402 lets one route list multiple networks in accepts.

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

  1. 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.
  2. 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).
  3. 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.
  4. 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's vct suffix and UCP's dated version, 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

Get new articles in your inbox

Technical deep-dives on Solana tooling, infrastructure, and ecosystem. No noise.

solanax402paymentsai-agentsmppap2stablecoinsresearch

DevRels · November 19, 2026

Seven agentic payment protocols in 2026: a developer's guide to x402, AP2, MPP, ACP, TAP, UCP and PayPal Agent Ready | devrels.xyz