AP2 vs. ACP vs. MCP: Which Agentic Commerce Protocol Should You Build For?

TL;DR

• AP2, ACP, and MCP aren't three competitors fighting for the same job: AP2 authorizes payments, ACP powers chat-surface checkout, and MCP handles catalog and cart access. Most merchants will end up touching more than one.
• ACP is the clearest cautionary tale for picking early: OpenAI scaled its own in-chat Instant Checkout back to a discovery-and-redirect model in March 2026, after real merchant enablement (reportedly a handful of Shopify merchants) fell well short of the “single integration” pitch.
• AP2 has the deepest backer bench (Google plus 60+ partner organizations across payments and enterprise software) but, as of today, no publicly named merchant deployment, an honest gap worth knowing before you treat backer logos as adoption proof.
• MCP's commerce role runs through Shopify's Storefront MCP, rolling out broadly across Shopify's merchant base through 2026; it isn't a payment-authorization protocol on its own, so it typically pairs with something else at checkout.

Why “picking a protocol” is the wrong question in 2026

Every comparison piece on AP2, ACP, and MCP is implicitly built around a “which one wins” frame, and that frame is the wrong one to plan a 2026 roadmap around. The three protocols don't compete for the same job:

• AP2 proves an agent had real authorization to pay
• ACP lets a business become purchasable directly inside a chat surface
• MCP lets an agent discover a catalog and manage a cart

A merchant asking “should I build for AP2 or ACP or MCP” is often really asking three separate questions at once, and answering them as if they were one is how a roadmap gets stuck on a bet that doesn't pay off.

ACP is the clearest evidence this happened already. When ChatGPT's Instant Checkout launched in late 2025:

• Etsy went live immediately
• Stripe named Glossier, Vuori, Spanx, and SKIMS as Shopify merchants coming soon
• The pitch was a “single integration” that would let a business “start selling through AI agents while retaining full control over what's sold”

By March 2026, OpenAI scaled that in-chat checkout back to a discovery-and-redirect model, after real enablement lagged well behind the pitch. A merchant that treated ACP integration as the readiness project, rather than one reversible layer on top of readiness, had to rework that bet within months.

What all three protocols actually require from merchants

Underneath the branding, all three protocols need the same foundation before they need anything protocol-specific:

• Complete, machine-readable product data: price, real-time availability, shipping terms, return policy
• A written position on what happens when an agent gets a purchase wrong

AP2's Mandates, ACP's Checkout API, and MCP's catalog tools all read that same underlying data; none of them create it for you. That's the groundwork that pays off no matter which protocol, or combination, ends up mattering for your buyers. For the fuller readiness checklist, structured data, a liability policy, and measurement, see how e-commerce brands are preparing for agentic commerce.

What changes if a protocol wins vs. loses adoption

If a protocol you bet on loses adoption, what you lose is whatever protocol-specific integration work you built around it, custom checkout logic, a single-vendor payment flow, an API contract that assumed that protocol was the only one you'd ever need. What you don't lose is structured product data, a liability policy, or measurement infrastructure, since none of that is protocol-specific in the first place. Structuring your roadmap so the reversible layer (protocol integration) is genuinely small, and the durable layer (readiness) is where the real investment goes, is what keeps a scaled-back protocol from becoming a wasted quarter.

AP2 (Google-led): what it is and who's backing it

The Agent Payments Protocol standardizes proof of authorization through two cryptographically signed “Mandates”:

• An Intent Mandate capturing what the user actually asked for
• A Cart Mandate locking the final price before payment

Together they create an audit trail showing an agent had real permission to spend, not just a plausible-looking request. Google published AP2 in September 2025 with a broad, named partner list across payments and enterprise software, among 60+ organizations:

• Mastercard, PayPal, American Express
• Coinbase, Adobe, Salesforce

Payment support is wide by design:

• Cards, digital wallets, bank transfers
• Stablecoins and other crypto payments, through a separate A2A x402 extension built with Coinbase, the Ethereum Foundation, and MetaMask

What AP2's own announcement doesn't include is a named merchant deployment. That's not a knock on the protocol, payment-authorization infrastructure is a layer retailers integrate through a processor or platform rather than announce individually, but it does mean “AP2 has the deepest backer bench” and “AP2 has proven retail adoption” are two different claims, and only the first one is currently verifiable from Google's own documentation.

ACP (OpenAI/Stripe-led): what it is and who's backing it

The Agentic Commerce Protocol standardizes a Checkout API and a Delegate Payment API that let a business become purchasable directly inside a chat surface, using tokenized payment credentials so the agent never touches a raw card number. OpenAI and Stripe are the joint maintainers, with governance moving toward a neutral foundation. Payment handling is more flexible than the “Stripe protocol” label suggests: a merchant can process through Stripe directly, or hand payment to another provider entirely while still using Stripe's fraud risk scores.

ACP's adoption story is the most public of the three, for better and worse:

• At launch (late 2025): Etsy went live with Instant Checkout; Stripe named Glossier, Vuori, Spanx, and SKIMS as Shopify merchants coming soon, pitched as a “single integration.”
• By March 2026: OpenAI scaled the in-chat checkout back to a discovery-and-redirect model, after real merchant enablement fell short. One industry analysis put actual Instant Checkout adoption at roughly a dozen Shopify merchants against that launch framing (a secondary-source figure, not confirmed by OpenAI or Stripe directly, so treat it as directional rather than official).

The protocol itself didn't disappear; it continues to be used outside that specific chat surface, and its own GitHub repository and Stripe's documentation remain the primary technical reference. But the gap between the launch pitch and what merchants actually enabled is the single most concrete data point in this entire comparison, and it's the reason “ACP has the most name recognition” and “ACP has the most retailer adoption” are no longer the same statement.

MCP-based commerce extensions: what they add

The Model Context Protocol, created by Anthropic as a general-purpose way for an AI system to connect to external data and tools, isn't commerce-specific on its own. Shopify's adaptation, Storefront MCP and Customer Accounts MCP, is what gives it a commerce role: an agent can discover a merchant's catalog, search products, and manage a cart through it. Shopify's own documentation is light on which merchants currently have it enabled or what integration effort looks like in practice, but the protocol is rolling out broadly across Shopify's merchant base through 2026 rather than requiring an individual opt-in negotiation the way ACP's early launch partners did.

What MCP explicitly doesn't do is authorize payment. It's a catalog-and-cart protocol, not a trust protocol, so Shopify's own checkout, or a payment-authorization layer like AP2, still has to handle the actual transaction. That division of labor is worth understanding on its own terms rather than as a gap: MCP being narrower in scope than AP2 or ACP isn't a weakness, it's why a merchant frequently ends up pairing it with something else instead of choosing it as a replacement for the other two.

Side-by-side comparison table

A fourth protocol sits just outside this comparison but is worth naming here too: Shopify and Google's Universal Commerce Protocol (UCP), published in January 2026 with Etsy, Target, Walmart, and Wayfair also backing it, currently carries more live agent-driven purchase activity than ACP's own in-chat checkout does. UCP isn't part of this piece's three-way comparison because it wasn't part of the question this piece was built to answer, but it's the single best piece of evidence for the “protocol-agnostic readiness first” argument above: the protocol with the earliest, loudest launch in this category is not the one with the most live volume seven months later.

FAQ

Can I support more than one protocol at once?

Yes, and for most merchants that's the more defensible default than picking one. Nothing about AP2, ACP, or MCP structurally prevents combining them, since they solve different layers of the same transaction rather than competing implementations of the same layer. A Shopify merchant already reachable through MCP for catalog and cart access can still add AP2-style payment authorization or an ACP checkout surface on top, without those choices conflicting.

Which protocol has the most retailer adoption today?

It depends what you're counting. By named backers and partner organizations, AP2 has the deepest bench. By actual live purchase volume through a chat-style checkout, MCP-adjacent commerce (via Shopify, which also underlies UCP) currently carries more real activity than ACP's own in-chat checkout does, a reversal from ACP's early lead when it launched alongside Instant Checkout in late 2025. Backer counts and live transaction volume are different signals, and a protocol can lead on one while trailing on the other.

What happens if my chosen protocol loses out?

What needs reworking or retiring:

• Custom checkout logic built around that one protocol
• A single-vendor payment flow
• An API contract that assumed only that protocol mattered

What doesn't need touching:

• Structured product data
• A written liability policy
• Measurement infrastructure for agent-driven transactions

None of that second list is protocol-specific. ACP's own March 2026 scale-back is the concrete version of this: merchants who'd invested primarily in protocol-agnostic readiness kept that work; merchants whose whole plan was “integrate with ACP” had to start over on the integration piece.

The Bottom Line

AP2, ACP, and MCP aren't rival answers to the same question, they're three protocols solving three different layers of an agentic transaction: authorization, chat-surface checkout, and catalog access. Building for “whichever one wins” is a bet against evidence that's already in: ACP had the loudest launch and the most public retreat within five months, AP2 has the deepest backer list and the least merchant-facing proof, and MCP's real strength is availability at platform scale rather than a splashy launch. The readiness work, structured product data, a liability policy, and measurement that survives whichever protocol a buyer happens to use, is what every path through this comparison has in common. Build that first, and the protocol question stops being the one that decides whether the quarter was wasted.