x402 vs MPP - Agentic Payments Compared

AI agents are no longer just answering questions. They are buying services, consuming APIs, and transacting autonomously. As this shift accelerates, a wave of agentic commerce protocols has emerged, but they are not all solving the same problem.

This article maps the landscape across the four major standards: x402, MPP, ACP, and UCP. It draws a distinction that most comparisons miss: two of these protocols handle machine-to-machine API payments, while the other two handle human-directed shopping through AI agents. Understanding which layer you are building for is the first decision every developer and merchant needs to make.

For builders in the machine-to-machine space, where API services get paid by autonomous agents in real time, the real challenge is not which protocol to choose. It is dealing with the fragmentation that has grown up around them. That is the problem PayAI's Mercantil Agent SDK is built to solve.

In a nutshell

• AI agents are becoming economic actors, but the infrastructure supporting them has split into two layers serving fundamentally different use cases.
• Machine-to-machine API payments (x402 by Coinbase, MPP co-authored by Tempo and Stripe): autonomous agents pay for services they consume directly. These are the protocols relevant to API builders and service monetizers.
• Human-directed agentic checkout (ACP by Stripe and OpenAI, UCP co-developed by Google and Shopify with Walmart, Target, Etsy, and Wayfair): a human buyer uses an AI agent to shop on their behalf. These are the protocols relevant to e-commerce merchants.
• The real pain point for API builders is fragmentation: even within x402 alone, merchants face 15+ facilitators across multiple chains, each with its own SDK, wallet setup, and catalog listing process.

The rise of agentic payments

What began as information retrieval - summarizing documents, answering queries - has evolved into autonomous purchasing and service consumption. The global AI agent software market is projected to reach $47.9 billion by 2030, growing at a CAGR of 43.9%.

This creates an immediate infrastructure problem. Legacy payment rails such as Stripe, Visa or PayPal were designed for humans. They require merchant accounts, API keys, manual onboarding, and a human in the loop for authorization. None of that works when an autonomous agent needs to pay $0.002 for a single API call at machine speed.

Enter agentic payment protocols. These systems embed payment directly into the web's native request–response flow, enabling pay-per-request micropayments settled in stablecoins on low-cost blockchains. The concept is not entirely new: HTTP status code 402 ("Payment Required") was reserved in RFC 7231 back in 2014, but no interoperable payment protocol was standardized for it until 2024–2025. Now the infrastructure is catching up to the vision. But as multiple protocols race to define the standard, the ecosystem is fracturing faster than it is consolidating.

Agentic payment protocols compared: x402 vs. MPP vs. ACP vs. UCP

The four major protocols are not all playing the same game. Before evaluating them, it is essential to understand the two distinct layers they operate on.

Layer 1: Machine-to-machine API payments. An autonomous agent pays for a service it consumes directly: an API call, a data feed, a compute task. Payment happens in milliseconds, without human involvement, at sub-cent scale. The protocols here are x402 and MPP.

Layer 2: Human-directed agentic checkout. A human buyer delegates a purchase to an AI agent. "Buy me a large black t-shirt under $40." The human authorizes the action; the agent executes it. The protocols here are ACP and UCP.

PayAI operates in Layer 1. The fragmentation analysis later in this article focuses specifically on that layer. But understanding all four protocols helps developers and merchants decide which parts of the agentic economy they are building for.

x402: The HTTP-native open standard

The x402 protocol is currently the most widely adopted agentic payment standard. Its design philosophy is simple: leverage the HTTP 402 status code to create a native request–response payment flow that any web server can implement.

How it works: When an agent requests a paid resource, the server returns a 402 response with payment instructions in the headers. The agent constructs a payment (typically a stablecoin transaction on a supported chain), attaches proof to the request, and retries. The server verifies payment and delivers the resource. The entire flow happens within standard HTTP semantics.

Strengths:

• Simplicity of integration. Adding x402 to an Express or FastAPI server requires as few as 5–15 lines of middleware code.
• Open and neutral. x402 is not owned by any single company. There is no vendor lock-in, and the protocol specification is freely available.
• Growing ecosystem. As of Q4 2025, 15+ facilitators are active across Solana, Base, Arbitrum, and other networks, making x402 the largest agentic payment ecosystem by facilitator and merchant count.
• Pay-per-request and usage-based pricing with stablecoins like USDC are natively supported.

Limitations:

• Ecosystem fragmentation. The very success of x402 has created its biggest challenge. With 15+ facilitators each operating its own SDK, wallet requirements, and catalog listing process, merchants must integrate with each one individually to reach the full buyer base.
• Blockchain-only payments. x402 does not yet natively support fiat rails like credit cards.
• Discovery is facilitator-specific. Being listed on one facilitator's catalog does not guarantee visibility on another's.

MPP: Machine Payment Protocol

MPP is an open standard for machine-to-machine payments co-authored by Stripe and Tempo Labs, launched on March 18, 2026. Like x402, it uses the HTTP 402 status code, but rather than inventing new header conventions, it plugs into the existing HTTP authentication framework via a WWW-Authenticate: Payment challenge-response pattern. This is the same model used by Basic, Bearer, and Digest auth.

How it works: A client requests a resource. The server responds with 402 and a WWW-Authenticate: Payment challenge describing what payment is needed. The client fulfills the payment via the specified payment method, then retries with an Authorization: Payment credential proving payment. The server verifies and returns the resource with a Payment-Receipt header.

Strengths:

• Payment-method agnostic. Unlike x402's blockchain-only model, MPP supports stablecoins (via the Tempo network), credit and debit cards (via Stripe), Bitcoin (Lightning via Lightspark), and custom payment rails through extensible method specifications that anyone can publish.
• Sessions for high-frequency micropayments. MPP's session model enables pay-as-you-go metering without requiring an on-chain transaction per request. Agents authorize a spending limit upfront and stream micropayments continuously.
• Production-grade primitives. Built-in idempotency, expiration, and request binding.
• IETF standards track. The core specification has been submitted to the IETF for standardization as the official HTTP 402 implementation.
• Significant institutional backing. Tempo raised $500M at a $5B valuation (led by Thrive Capital and Greenoaks). Stripe co-authored the protocol, and design partners include Anthropic, DoorDash, Mastercard, OpenAI, Revolut, Shopify, Standard Chartered, and Visa. At launch, the payments directory listed over 100 integrated services including OpenAI, Anthropic, Google Gemini, Alchemy, and Dune Analytics.

Limitations:

• Newer ecosystem. MPP launched in March 2026, so developer tooling is less mature than x402's, which has had a year-long head start building facilitators, SDKs, and catalog infrastructure.
• Session limitation. While MPP is rail-agnostic in design, sessions currently run only on the Tempo chain due to the on-chain escrow requirement.
• Stablecoin acceptance is currently for US-businesses only via Stripe. Customers can use stablecoins as payment globally, but currently only US businesses can accept stablecoin payments.

ACP: Agentic Commerce Protocol

ACP is an open standard co-developed by Stripe and OpenAI for human-directed e-commerce checkout through AI agents. This is a critical distinction: while x402 and MPP handle machine-to-machine API payments (an agent pays for a service it consumes), ACP handles the scenario where a human says "buy me a large black t-shirt under $40" and an AI agent executes that purchase with a merchant.

ACP launched on September 29, 2025, powering OpenAI's Instant Checkout in ChatGPT, initially enabling US users to buy from Etsy sellers. Shopify merchants followed shortly after, with brands like Glossier, Vuori, Spanx, and SKIMS among the early partners.

How it works: ACP defines two complementary specifications. Agentic Checkout is a REST API between agents and sellers that manages checkout sessions: creating a cart, selecting fulfillment options, applying discounts, and completing payment. Delegate Payment handles secure tokenization of the buyer's payment credentials via Shared Payment Tokens (SPTs), which are scoped to a specific merchant and cart total, so the agent can relay payment without ever holding raw card data. The human buyer authorizes payment; the seller remains the merchant of record.

Strengths:

• Solves the real e-commerce agent problem. Rather than agents scraping websites and battling CAPTCHAs, ACP gives them a deterministic, programmatic checkout interface.
• Capability negotiation. Agents and sellers exchange a capabilities object at session creation, so incompatibilities surface before payment, not during.
• Broad adoption. Etsy, Shopify, URBN, Ashley Furniture, Coach, Kate Spade, commercetools, and dozens of major retailers have adopted ACP.
• PSP-agnostic. Businesses not on Stripe can still implement ACP with their existing payment providers.

Limitations:

• Not relevant for API/service monetization. ACP is built for physical and digital goods checkout with a human buyer in the loop. It does not address machine-to-machine micropayments.
• Currently US-focused. The initial rollout is limited to US buyers and merchants, with broader geography on the roadmap.
• Single-item purchases only (for now). Multi-item cart support is on the roadmap but not yet live.

PayAI does not currently operate in the ACP layer. It is included here for market context.

UCP: Universal Commerce Protocol

UCP is an open-source standard co-developed by Google and Shopify, with Walmart, Target, Etsy, and Wayfair as co-developers, and endorsed by more than 20 global partners including Visa, Mastercard, Amex, PayPal, Stripe, Adyen, Best Buy, The Home Depot, Macy's, and Zalando. It launched at the National Retail Federation conference on January 11, 2026.

Like ACP, UCP targets human-directed agentic checkout, not machine-to-machine API payments. But where ACP focuses on the checkout moment, UCP is substantially more ambitious, as it aims to cover the entire commerce lifecycle from product discovery through post-purchase order management.

How it works: UCP defines a capability-based architecture where merchants and agents each declare what they support, and the protocol negotiates the intersection dynamically. It covers checkout session management, identity linking via OAuth 2.0, and order management including tracking, returns, and refunds. UCP is transport-agnostic, supporting REST, MCP, Agent2Agent (A2A), and Agent Payments Protocol (AP2) bindings.

Strengths:

• Full commerce lifecycle. Discovery, checkout, identity linking, order tracking, returns, loyalty programs, and subscription billing, to cover the entire shopping journey.
• Massive industry coalition. The broadest co-development and endorsement list of any agentic commerce standard, spanning retailers, payment networks, and platforms.
• Layered extensibility. Merchants implement only the capabilities they need. Extensions are independently versioned, so the core protocol stays stable while the ecosystem evolves.
• Already live. Google's AI Mode checkout is live for eligible US retailers via UCP, with global expansion planned through 2026.

Limitations:

• Not relevant for API/service monetization. Like ACP, UCP is built for retail commerce with a human buyer.
• Complexity at scale. The ambition of covering every commerce vertical introduces real integration complexity for merchants with specialized requirements.

PayAI does not currently operate in the UCP layer. It is included here for market context.

The two layers of agentic commerce

Understanding which layer applies to your use case is the most important decision before choosing a protocol.

Layer 1 deep-dive: x402 vs. MPP

For API builders and service monetizers operating in the machine-to-machine payment layer, here is how the two protocols compare.

The fragmentation problem

The protocol comparison above reveals an important truth: the biggest challenge facing agentic payments is not choosing the right protocol. It is dealing with the fragmented ecosystem that has grown around them.

Even within x402, the most mature protocol, merchants face 15+ active facilitators spread across Solana, Base, Arbitrum, and other networks. Each operates its own SDK, and maintains its own catalog for agent discovery. The result: developers must utilize separate integrations per facilitator and per chain. Agents on one network cannot discover merchants who only integrated a different one. Network effects that should drive explosive growth are diluted across incompatible silos.

The merchant's dilemma

Consider a developer who has built a specialized image analysis API and wants to monetize it through agentic payments. They pick a facilitator and chain, spend a few hours integrating, and go live. Agents or catalogs using that specific facilitator can now discover and pay for the service. But agents on other facilitators, or other chains, cannot.

Each additional integration adds hours of development time plus ongoing maintenance. The catalog problem compounds this: being listed on one facilitator's bazaar does not mean visibility on others. Agentic clients rely primarily on automated marketplace discovery, so merchants not listed in major catalogs miss the vast majority of potential traffic.

Every hour spent on payment plumbing is an hour not spent improving the core product. The demand side suffers equally: an agent with a Solana wallet cannot pay a merchant who only accepts on Base. An agent querying one catalog sees an incomplete picture of available services.

The market cannot reach critical mass while it remains this fragmented.

What the market needs: Abstraction, not another protocol

The temptation in a fragmented market is to propose yet another standard. But history suggests a different path.

Before Stripe, merchants accepting online payments had to integrate with Visa, Mastercard, American Express, Discover, and regional processors individually. Stripe unified those fragmented integrations into a single developer experience. Critically, Stripe did not replace Visa or Mastercard, it abstracted them. The underlying networks continued to operate; the aggregator removed the friction of dealing with each one individually.

Agentic payments are at the same inflection point. x402 and MPP are the underlying machine-to-machine payment networks. And tomorrow may bring yet another protocol. What is missing is the aggregation layer. That is where PayAI operates.

The agentic payment landscape will consolidate: position yourself now

The agentic commerce landscape is innovating across two distinct layers. ACP and UCP are redefining how humans shop through AI agents, with massive institutional backing and live rollouts underway. x402 and MPP are redefining how autonomous agents pay for the services they consume. This is where fragmentation is most acute and where abstraction delivers the most value.

The merchants who establish presence across all networks and catalogs while the ecosystem is still forming will capture disproportionate agent traffic as the market scales. The question is not whether consolidation will happen. It is whether you will be positioned to benefit when it does.