Every Agent Payment Protocol Compared: X402, ACP, UCP, AP2 (2026)

There are now four major agent payment protocols — and that number will grow. If you’re building with AI agents in 2026 and trying to figure out which one to use, you’ve hit a real navigation problem. The protocols have different scopes, different backers, and different constraints. Some solve layer 1. Some solve layer 3. None of them solve everything.

This post maps all four: what each does, what it does genuinely well, and where it stops. The goal is a comparison you can actually use — not marketing dressed up as analysis. ATXP’s position in this landscape is saved for the end, because it only makes sense after you understand what the protocols do and don’t cover.

The ATXP robot holds a comparison diagram of four agent payment protocol nodes

Why the Agent Payment Protocol Question Matters Now

The agent payment protocol question matters now because 2025–2026 is the window in which standards are being set. Protocols that earn developer adoption now will be the default layer for the next decade of agent infrastructure. Developers building agent applications today are making architectural choices — knowingly or not — about which payment layer their agents will depend on.

The fact that four significant protocols exist simultaneously is a sign of genuine uncertainty about where the standard will land. X402 shipped in May 2025 and has 50 million transactions behind it. Stripe’s ACP went live in ChatGPT in early 2026. Google announced UCP in January 2026. AP2 arrived in September 2025. The race is active, not settled.

For developers, this creates a real question: build on the protocol with the most traction? The most enterprise backing? The least crypto dependency? The broadest scope? This post gives you the data to answer that for your specific situation.

x402 let's you make any API call with payment embedded right in the API call itself. No sign up, API key, or credit card required. AI Agents will need an easier way to pay for data, get through pay walls, and spin up resources. Is your API x402 enabled?
— Brian Armstrong (@brian_armstrong) May 2025

The Four Protocols: Quick Reference

Definition — Agent Payment Protocol

An agent payment protocol is a standardized specification that defines how an autonomous AI agent initiates, authorizes, and settles financial transactions without human involvement at each step. Different protocols operate at different layers: some handle the HTTP request, some handle merchant checkout, some handle the authorization chain, and some handle the full commerce journey from discovery to fulfillment.

— ATXP

An agent payment protocol is a standardized specification that defines how an autonomous AI agent initiates, authorizes, and settles financial transactions without human involvement at each step. Different protocols operate at different layers: some handle the HTTP request, some handle merchant checkout, some handle the authorization chain, and some handle the full commerce journey from discovery to fulfillment.

The key fact: each of these protocols handles one or two layers of the problem, not the full stack.

Protocol	Primary Layer	Launched	Backer	Open Source/Spec	Crypto Required	Agent Identity
X402	HTTP payment rails	May 2025 (V2: Dec 2025)	Coinbase	Yes (open source)	Yes (USDC on Base)	No
Stripe ACP	Merchant checkout	Late 2025 / live 2026	Stripe + OpenAI	Yes (open spec)	No	No
Google UCP	Full commerce journey	January 2026	Google + Shopify	Partial	No	No
Google AP2	Authorization / trust	September 2025	Google	Partial	No	Partial (auth only)
ATXP	Layer 0 — identity + payments + email + tools	—	Circuit & Chisel	No	No	Yes (full)

The last row in that table is what the rest of this piece is building toward. First, the four protocols deserve an honest look on their own terms.

Coinbase X402

X402 is the most developer-native protocol on this list, and by transaction volume it is the most proven.

What it is: An open-source protocol that extends the HTTP 402 “Payment Required” status code — a status code that has existed in the HTTP spec since 1991 but was never widely implemented — to enable machine-to-machine micropayments. When an agent hits a service that requires payment, the server returns a 402 response with payment instructions. The agent pays in USDC on Coinbase’s Base blockchain and retries the request. The protocol is on GitHub, maintained by Coinbase, and fully open source.

Key facts:

Launched May 2025; V2 released December 2025
50+ million transactions processed as of early 2026
USDC on Base for settlement; fiat on-ramp via Coinbase Commerce
Ecosystem includes Circle, Tavus, and noted integrations with Anthropic, AWS, and Google Cloud

What X402 does well: The HTTP 402 mechanism is genuinely elegant. It’s interoperable by design — any HTTP client can implement it, and any server can return a 402 response. The open-source structure means developers can read the full spec, contribute to it, and build on it without depending on Coinbase’s roadmap decisions. Fifty million transactions isn’t a press release stat — it’s a demand signal that agent-to-service payments are real and growing. The pay-as-you-go structure is also a natural fit for agent workloads, where usage is unpredictable and subscription models create cost mismatch.

Where it stops: X402 is payment rails. It does not give an agent an identity, an email address, or access to tools. It doesn’t know who the agent is — only that the agent can pay. Every agent that uses X402 still needs to come from somewhere, with some persistent identity, to interact with services in any stateful way. That identity layer is outside X402’s scope by design. The crypto dependency — USDC on Base — is also a real friction point for developers who aren’t building in the Web3 ecosystem. Fiat paths exist via Coinbase Commerce, but the architecture is crypto-first.

Best for: Developers building crypto-native agent applications who need payment rails and are comfortable with USDC. Strong fit for API providers who want to monetize per-call with minimal infrastructure.

Not ideal for: Developers who want to avoid crypto complexity, teams that need full-stack identity and tooling, or anyone building for human consumers.

External reference: x402.org

The x402 payment flow: an agent hits a 402 gate, sends a USDC payment, and retries through

Stripe ACP

ACP is the protocol with the most enterprise distribution already in place — and the clearest “missing layer” problem.

What it is: The Agentic Commerce Protocol is an open specification for how AI agents transact across merchants and AI systems. Co-developed with OpenAI and announced in late 2025, it was live in ChatGPT as of early 2026. PayPal, Salesforce, and Shopify are adopting it. The spec defines how agents communicate with merchants, handle checkout flows, and initiate payments through existing Stripe infrastructure.

Key facts:

Co-developed with OpenAI; announced late 2025; live in ChatGPT early 2026
PayPal, Salesforce, Shopify adopting as of early 2026
Open specification published by Stripe; implementation uses existing Stripe pricing
Stripe’s separate “Tempo” blockchain effort is a related but distinct stablecoin settlement layer

What ACP does well: Stripe’s existing merchant relationships are a structural advantage that no other protocol on this list can match. If you want to accept payments from AI agents as a merchant, ACP gives you a path using the Stripe infrastructure you likely already have. The OpenAI co-development means ACP is embedded in the most widely deployed AI system in the world — that’s distribution most protocols would take years to build. The enterprise adoption pipeline (PayPal, Salesforce, Shopify) gives ACP legitimacy in procurement and compliance conversations that pure developer protocols don’t have.

Where it stops: ACP is explicitly a merchant checkout layer. It describes how agents transact at the point of sale — not who the agent is before it gets there. Stripe has been transparent that it is not building the agent identity layer. An agent using ACP still needs to arrive with identity, payment credentials, and decision-making capability already established. The spec is also complex relative to what individual developers building single agents actually need — it’s architected for the enterprise merchant side, not the developer building the agent. Small teams frequently describe it as underserving their use case.

Best for: Enterprises and large merchants wanting to accept payments from AI agents through established Stripe infrastructure. Strong fit for any team already running Stripe in production.

Not ideal for: Individual developers building agents rather than accepting them; consumers; any use case needing agent identity, tooling, or email.

External reference: Stripe blog — ACP announcement

Google UCP

UCP has the broadest stated scope of any protocol in this comparison — and the highest walled-garden risk.

What it is: The Universal Commerce Protocol is Google’s effort to standardize the full commerce journey for AI agents, covering discovery, search, checkout, and fulfillment. Announced in January 2026 and co-developed with Shopify, it integrates directly with Google Shopping, AI Overviews, and Gemini. Twenty or more retail and platform partners signed on at launch.

Key facts:

Announced January 2026; co-developed with Shopify
20+ retail and platform partners at launch
Integrates with Google AI Overviews, Google Shopping, and Gemini
Shopify partnership = access to 5M+ merchants
Broader scope than ACP: covers discovery through fulfillment, not just checkout

What UCP does well: Google’s distribution is a genuine differentiator. When an agent interacts with AI Overviews or Google Shopping, UCP provides the underlying commerce layer. No other protocol has access to that traffic. The Shopify partnership gives UCP direct access to a massive merchant base that didn’t need to be convinced to join a new network — they were already there. The scope ambition — handling discovery, search, checkout, and fulfillment in a unified spec — is the right long-term direction. If it ships completely, it’s the most end-to-end protocol on this list.

Where it stops: That scope ambition also means UCP is the most complex and slowest to fully ship. The walled-garden risk is the highest here: Google controls both the protocol and the primary distribution mechanism. Agents built on UCP are agents built for the Google ecosystem — compatibility with non-Google AI systems is limited by design. There is no agent identity layer in UCP, and the “partial” payments support runs through Google Pay and Shopify Payments rather than a purpose-built agent payments infrastructure.

Best for: Large retailers wanting AI-powered commerce through the Google/Shopify ecosystem. Strong fit for Shopify merchants who want to integrate with Google Shopping’s AI features.

Not ideal for: Developers building agents (not accepting them), consumers, teams outside the Google ecosystem, anyone needing agent identity.

External reference: Google Developer Blog (UCP/AP2 announcement)

Google AP2

AP2 is the narrowest protocol on this list, and that narrowness is its genuine strength.

What it is: The Agent Payment Protocol (also sometimes called Agent Purchase Protocol) is Google’s authorization and trust layer for agent-initiated purchases. Announced in September 2025, it focuses on a specific question that no other protocol addresses directly: how does a business authorize an AI agent to spend money on its behalf, with audit trails and spend controls? AP2 works alongside UCP — AP2 is the auth/trust layer; UCP is the commerce journey layer.

Key facts:

Announced September 2025
Enterprise/Google Cloud focus
Core features: spend policies, spend limits, audit trails
Designed to integrate with Google Cloud infrastructure
No public consumer product currently live

What AP2 does well: AP2 addresses a real gap that the other protocols sidestep. X402, ACP, and UCP all assume that the agent is authorized to spend — they don’t define how that authorization was established or how it can be revoked, audited, or constrained. AP2 fills that gap. Spend policies and audit trails are genuinely valuable for enterprise deployments where finance teams need to be able to reconstruct what an agent spent and why. The Google Cloud integration gives AP2 enterprise credibility in exactly the buying center that cares most about governance. This is the “Level 3.5” problem — between persistence and full delegation — and AP2 takes it seriously.

Where it stops: AP2 is narrow by design, and that narrowness limits its applicability outside Google Cloud enterprise environments. There is no consumer-facing product, no public transaction data, and no developer community comparable to X402’s open-source ecosystem. The scope is genuinely limited to authorization — it does not handle identity, email, tooling, or the broader agent lifecycle. And for teams not already on Google Cloud, the integration story is thin.

Best for: Enterprise companies on Google Cloud that need audit trails and spend policies for AI agent purchasing.

Not ideal for: Individual developers, startups, non-Google Cloud environments, consumers, use cases needing identity or tool access.

AP2 authorization chain: a business delegates spend authority through policy verification nodes down to the agent

What None of Them Cover

Here’s the gap the comparison table exposes: not one of these four protocols gives an agent a persistent identity.

X402 gives an agent a way to pay. ACP gives a merchant a way to accept that payment. UCP gives the commerce journey a standardized flow. AP2 gives an enterprise a way to authorize the agent’s spending. But none of them answer the question: who is the agent? Where does it live? How does it receive a confirmation email? How does the service on the other end recognize it the next time?

This is the “missing basement” problem. The five-level staircase of agentic commerce — from eliminating web forms to full anticipation — rests on an assumed foundation of agent identity, permissions, and tool access. That foundation is not built into any of the four protocols. It has to come from somewhere else.

The other gap is tooling. An agent that can pay still needs to actually do things: browse the web, generate an image, run code, send and receive email, call APIs. Payment rails don’t include tools. Merchant checkout specs don’t include tools. Authorization layers don’t include tools. Every developer building on top of these protocols is still assembling a separate tool layer from individual API subscriptions — managing API keys, subscription billing, and access control for each service independently.

“The agents we were working with in late 2024 were obviously on the right track — but they needed to use my account for everything. Navigate a browser. Input card details. Nothing like the economic actors we envisioned — I stress both words independently. So we gave them eyes, ears, hands, legs, and a wallet.”

— Louis Amira, co-founder, ATXP

This is the Layer 0 problem. The four protocols are all Layer 1 or above — they handle payment, checkout, authorization, or discovery. Layer 0 is the layer below all of them: the persistent identity, the email address, the tool access, the payment account that makes it possible for an agent to show up at those layers and actually be recognized as a consistent actor.

ATXP is the Layer 0 below every commerce protocol. It gives agents an agent handle, an @atxp.email address, a payment account, and access to 14+ tools — in one account, set up with a single command. An agent running on ATXP can then use X402 for payments, interact with ACP-compliant merchants, or operate within UCP-structured commerce flows. ATXP isn’t one of the four protocols. It’s what makes all four work for actual agents.

npx atxp

That gives your agent a persistent identity, a funded payment account, an email address, and access to 14+ tools. No subscriptions, no API keys required. See how it works →

ATXP as Layer 0 foundation beneath X402, ACP, UCP, and AP2 protocol stack — agent identity and tools at the base

How to Choose

Start with what layer your use case actually lives in.

If you are building an API service that charges per call: X402 is the right starting point. The HTTP 402 mechanism is elegant, the open-source ecosystem is active, and the pay-as-you-go model fits per-call pricing naturally. Accept that you’re building in a crypto-native environment and plan accordingly.

If you are a merchant or enterprise wanting to accept payments from AI agents: ACP is the answer, especially if you’re already on Stripe. The enterprise adoption pipeline (PayPal, Salesforce, Shopify) means ACP is becoming the default for merchant-side agent commerce. Implementation complexity is real — factor that into your timeline.

If you are a large retailer in the Google/Shopify ecosystem: UCP gives you the broadest coverage of the commerce journey and the distribution advantage of Google Shopping and AI Overviews. Accept that you’re building for the Google ecosystem specifically and that non-Google AI compatibility is limited.

If you are an enterprise on Google Cloud that needs spend governance: AP2’s audit trails and spend policies are the most mature answer to the authorization problem. The narrow scope means you’ll still need other layers for the full agent lifecycle.

If you need a full-stack agent — one that has an identity, can send and receive email, can pay for things, and can use tools without manual API key management: None of the four protocols cover that. That’s the Layer 0 problem, and it’s what ATXP exists to solve. You can use ATXP alongside any of the four protocols above — they’re not in competition. X402 handles the payment rails; ATXP provides the identity and tool layer the agent needs before it can use those rails.

The comparison in the table above is a starting point. The honest version of this analysis is that these protocols are not mutually exclusive. They handle different layers. A production agent stack in 2026 is likely to use two or three of them together — with something at Layer 0 that none of them provide.

Frequently asked questions

What is an agent payment protocol?

What is Coinbase X402?

X402 is an open-source payment protocol that uses the HTTP 402 “Payment Required” status code to enable machine-to-machine micropayments. Launched by Coinbase in May 2025, it processes payments in USDC on the Base blockchain and had processed over 50 million transactions by early 2026. It is best suited for crypto-native developers who need payment rails and are comfortable with USDC.

What is Stripe ACP (Agentic Commerce Protocol)?

ACP is an open specification co-developed by Stripe and OpenAI that defines how AI agents transact across merchants and AI systems. It is live in ChatGPT as of early 2026 and is being adopted by PayPal, Salesforce, and Shopify. ACP focuses on the merchant checkout layer — it does not include an agent identity system.

What is Google UCP (Universal Commerce Protocol)?

UCP is Google’s protocol for standardizing the full commerce journey for AI agents, from discovery through fulfillment. Announced in January 2026 and co-developed with Shopify, it has 20+ launch partners and is tightly integrated with Google Shopping and AI Overviews. It is designed for large retailers in the Google/Shopify ecosystem.

What is Google AP2?

AP2 is Google’s authorization and trust layer for agent-initiated purchases. Announced in September 2025, it focuses on spend policies, audit trails, and the question of how businesses authorize AI agents to spend money on their behalf. It works alongside UCP and is geared toward enterprise environments on Google Cloud.

Which agent payment protocol should I use?

It depends on what layer your use case lives in. X402 for per-call API payment rails. ACP for merchant-side enterprise checkout. UCP for Google/Shopify commerce. AP2 for enterprise authorization and spend governance on Google Cloud. If you need agent identity, email, and tools — that’s Layer 0, which none of the four protocols cover. See the “How to Choose” section above for the full decision tree.

These four protocols represent real progress. X402 has 50 million transactions behind it. ACP is live in ChatGPT. UCP has Shopify’s merchant network. AP2 is solving a governance problem that every enterprise will eventually face. None of this is vaporware.

But each one handles one layer of a multi-layer problem. The protocol landscape in 2026 is not “choose one” — it’s “understand which layer each one covers, decide which layers you need, and fill in the rest.” The layer that none of them fill in — persistent identity, email, unified tool access — is the one that determines whether an agent can show up as a real actor in any of these systems. Build that first, and the protocol choice becomes much simpler.

If you’re ready to give your agent that foundation: npx atxp — identity, payments, email, and 14+ tools in one account. Learn more at atxp.ai/how-it-works, or read what an AI agent actually needs to function if you’re earlier in the research.