UCP vs ACP: Which Gets You Selected

The one-line difference

Read the two protocols by the ecosystem each serves, not as rivals competing for your integration budget. The Agentic Commerce Protocol (ACP), an open standard from OpenAI and Stripe announced on 29 September 2025, is a checkout standard (agent-ready checkout plus a product feed and delegated payment) and it launched as the rail behind ChatGPT's Instant CheckoutSpec-factStripe + OpenAI, Instant Checkout announcement. The payment side of ACP widened beyond Stripe: PayPal announced on 28 October 2025 that it would adopt ACP and support payments processing for merchants using Instant Checkout in ChatGPTReportedPayPal press release (2025-10-28). The in-chat purchase itself did not last in that form: by March 2026, reporting described OpenAI scaling back the in-chat checkout experience and routing transactions through merchant sites and apps insteadReportedForbes, Jason Goldberg (2026-03-10), and OpenAI's own merchant page now states the shift plainly: OpenAI says it is moving away from a standalone Instant Checkout experience in ChatGPT and prioritizing shopping discovery and merchant-owned checkout, so users discover and evaluate products in ChatGPT while purchases complete on the merchant's own website or appSpec-factOpenAI, ChatGPT for merchants. The Universal Commerce Protocol (UCP), Google's open standard announced at NRF 2026 on 11 January 2026, is broader: it lets an agent complete discovery, checkout, and post-purchase without leaving the AI surface, and is described as vendor-agnostic rather than controlling which product is presentedSpec-factGoogle, NRF 2026 remarks (blog.google).

Two name traps worth clearing first: it is the Universal Commerce Protocol, not "Universal Cart" (that is Google's consumer cart product), and it is the Agent Payments Protocol (AP2), plural, in the payment layer below both. See ACP and UCP in the glossary for the two-sentence anchors. The rest of this page is the practitioner's version of the difference: what each covers, which engine each reaches, and why the answer for most catalogs is "both."

The two protocols at a glance

Every date, scope, and reach line in this table is sourced in the dimension-by-dimension detail below: the table is the scannable summary, the prose carries the citations.

Scope compared: discovery, checkout, post-purchase

The cleanest way to hold the two apart is by how much of the shopping journey each one standardizes. ACP concentrates on the transaction. ACP's job is programmatic checkout (turning an agent's intent into a completed purchase through an agent-ready checkout, a product feed, and a delegated payment token), not organizing the discovery step that precedes itSpec-factStripe + OpenAI, Instant Checkout announcement. The spec still says that; what has shifted is which half of it ChatGPT deploys in production. OpenAI's merchant documentation states that ACP today supports product discovery and personalized recommendations through shared product data, and that over time it will expand to support the full shopping journey with deeper integrations and APIsSpec-factOpenAI, ChatGPT for merchants. UCP draws a wider box, though not all of it is live yet. UCP is designed to span the full journey an agent takes (discovery, checkout, and post-purchase) as a single abstractionSpec-factGoogle, NRF 2026 remarks (blog.google), but Google's own UCP developer guide lists post-purchase order tracking and returns as an upcoming feature on its roadmap, not a capability shipped todaySpec-factGoogle: Universal Commerce Protocol developer guide. On that specific piece, ACP is currently ahead: it already ships return-policy fields, while UCP's order-management and returns scope remains a stated direction rather than a working capability.

The rest of the UCP roadmap has started to move, in announced stages. In March 2026 Google announced a Cart option letting agents save or add multiple items to a cart from a single store, a Catalog capability for agents to retrieve real-time product details such as variants, inventory, and pricing, Identity Linking so shoppers keep loyalty and member benefits, and a simplified UCP onboarding flow in Merchant Center, rolling out over the coming monthsReportedGoogle, UCP updates (blog.google) (2026-03-19). Geography is widening on the same announced-not-assumed basis: at Google Marketing Live in May 2026, Google said UCP-powered checkout would roll out across Canada and Australia in the coming months and later to the UK, with Google Pay checkout available at retailers including Nike, Sephora, Target, and WalmartReportedGoogle Marketing Live shopping updates (blog.google) (2026-05-20). Treat both as rollout plans dated to their announcements, not availability you can bank on today; post-purchase tracking and returns stay on the roadmap either way.

This is a comparison of where you get selected, not an implementation guide: the field-by-field mechanics are the official docs' turf, and we link out to them below rather than reproduce them. For a practitioner, the scope difference boils down to what each rail takes for granted: a checkout-only rail assumes an agent has already decided to buy from you and just needs to complete the purchase; a discovery-through-post-purchase rail is trying to own more of the loop. Neither, crucially, ranks your products for you. Both explicitly disclaim the selection step, which is the layer this handbook exists to help you win.

Which engine each protocol reaches

For a merchant, scope matters less than reach: a protocol is only worth your time if it carries you to an agent your buyers actually use. Both mappings are confirmed by primary sources.

ACP is confirmed on the OpenAI side, though what riding it buys you has changed shape. ACP launched on 29 September 2025 as the rail behind ChatGPT's Instant CheckoutSpec-factStripe + OpenAI, Instant Checkout announcement, OpenAI scaled that in-chat checkout back by March 2026, routing transactions through merchant sites and apps insteadReportedForbes, Jason Goldberg (2026-03-10), and OpenAI's merchant documentation now frames ChatGPT shopping as discovery-first: merchants share ACP product feeds so their products appear and stay accurate in results, and customers complete purchases on the merchant's own website or appSpec-factOpenAI, ChatGPT for merchants. ACP-readiness is still how ChatGPT reads your catalog; the purchase itself now lands on your site. UCP is confirmed on the Google side. Google states that adopting UCP enables agentic actions on AI Mode in Google Search and Gemini, starting with direct buyingSpec-factGoogle: Universal Commerce Protocol developer guide.

A third engine now sits on both rails at once. Stripe states that Microsoft's Copilot Checkout, launched 8 January 2026, runs on the Agentic Commerce Protocol, with a Shared Payment Token issued to the merchant, who remains the seller of recordReportedStripe newsroom (2026-01-08). On the feed side, Microsoft announced on 21 April 2026 that UCP-ready feeds in Microsoft Merchant Center were generally available to everyone in the US, with Copilot Checkout expanded to more than 500,000 merchantsReportedMicrosoft Advertising blog (2026-04-21). So Copilot consumes ACP for checkout and UCP for feeds, which means neither protocol buys you a single engine anymore; the same integration increasingly counts twice. The per-engine playbooks live at ChatGPT shopping optimization and Gemini and Google AI Mode ranking, and the shared cross-engine view (including the Copilot rail detail) is on the AI shopping platforms hub.

Fulfillment and returns: what is actually in scope

A common but wrong belief is that these protocols stop at "add to cart and pay" and ignore delivery and returns. That was never true of ACP, and it is worth correcting because it changes what you can promise an agent. ACP's checkout schema has modeled shipping and fulfillment options since its launch spec, and by the 2026-01-30 spec version also exposes pickup, local delivery, delivery windows, and return-policy fieldsSpec-factACP schema, spec/2026-01-30 (agentic-commerce-protocol/agentic-commerce-protocol). There is a real limit, though, and it sits at returns. Under ACP, end-to-end returns and RMA processing remain the merchant of record's responsibility: the protocol exposes return-policy fields, not a returns pipeline you can hand offSpec-factStripe + OpenAI, Instant Checkout (ACP).

UCP looks structural at first glance, but the returns piece specifically is not live yet. Google's UCP developer guide places post-purchase order tracking and returns under its roadmap of upcoming features, not among what UCP ships todaySpec-factGoogle: Universal Commerce Protocol developer guide. On this specific dimension, ACP is currently ahead of UCP: its return-policy fields are already shipped, while UCP's returns and order-management scope remains a stated future direction rather than a working capability.

Why most merchants implement both

The two rails grew up serving different engines, so the protocols never competed for one audience the way rival standards usually do, and Copilot consuming both only sharpens that. The practical implication is that ACP and UCP reach additive agent audiences (ChatGPT on one side, the Google surfaces on the other, with Microsoft Copilot drawing on both rails), so for most catalogs the return-maximizing move is to be legible to both rather than to bet a single integration on one ecosystemHypothesis (our analysis). This is our reasoning from the reach mapping above, not a measured result; the magnitude of the gain depends on where your buyers actually shop, which is a thing to measure rather than assume.

The load-bearing caveat is the one from the takeaways: implementing either protocol is an eligibility step. It makes you transactable inside that ecosystem. It does not make an agent choose you over a competitor who is equally transactable. Doing both simply widens the set of agents that can pick you; the ACO guide and the platform pages are about making them actually do it.

What a small store should do first

Most stores should do both, as the section above argues. But a small team rarely has the capacity to stand up two integrations at once, so the honest question becomes not "which protocol" but "which one first."

An early practitioner-facing framing from No Hacks argues that for a small merchant the choice is largely upstream of the spec: it comes down to which commerce platform you run (your platform carries the protocol coverage) and how clean your product data is, more than an ACP-vs-UCP spec decisionReportedNo Hacks, Slobodan Manic (2026-05-14). That reframing helps because it shifts the first decision off the protocol and onto things you already control.

So the practical starting point is to check whether your commerce platform already carries one of these rails, then get your product data in order. When you genuinely can influence the order, we would start with the rail that reaches the engine your buyers already use: ACP is the rail into ChatGPT shopping, UCP the rail into Gemini and Google AI Mode, as mapped in "Which engine each protocol reaches" aboveHypothesis (our analysis).

This is sequencing, not a permanent one-or-the-other. Both stays the goal. The deeper leverage sits upstream of either protocol: get your product feed AI-readable, then win the pick over an equally transactable competitor, which is the work the platforms hub is for.

The payment layer beneath both

Sitting under UCP and ACP is a separate question (can an agent be trusted to pay on a shopper's behalf), handled by payment protocols like AP2, Visa's Trusted Agent Protocol, and Mastercard Agent Pay. They are worth knowing because they are table stakes for being a selectable merchant, but they are deliberately agnostic about which merchant gets chosen, so they sit outside the selection contest this page is about. We cover them separately in agentic payment protocols, explained, and AP2 has a short glossary anchor.

Where to implement each (link out)

This page owns the which; the official sources own the how, and we send you to them rather than reproduce a spec that will drift. For ACP, start at the Agentic Commerce Protocol repository(opens in new tab) (open standard, schema, and reference material). For UCP, start at Google's UCP developer guide(opens in new tab), the canonical implementation reference; the NRF 2026 announcement(opens in new tab) remains the original primary source for the launch itself. When you are ready to translate either integration into actual selection wins, come back to the platforms hub and the per-engine pages.