# UCP vs ACP: Which Gets You Selected
> UCP (Google) spans discovery, checkout, and post-purchase; ACP (OpenAI + Stripe) is checkout-focused and powers ChatGPT's Instant Checkout. Because each reaches a different agent audience, most merchants implement both, not one.
## 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 powers ChatGPT's Instant Checkout. 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 presented.
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](/glossary/#acp) and [UCP](/glossary/#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 it. 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 abstraction, 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 today. 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.
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. The practitioner reading of the scope difference is simple: 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. ACP is the rail behind ChatGPT's Instant Checkout, so being ACP-ready is how a purchase completes inside ChatGPT. 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 buying. The per-engine playbooks live at [ChatGPT shopping optimization](/chatgpt-shopping-optimization/) and [Gemini and Google AI Mode ranking](/gemini-shopping-ranking/), and the shared cross-engine view is on the [AI shopping platforms hub](/platforms/).
## 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 fields. 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 off.
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 today. 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.
If an agent can see a clear return policy and delivery window, it has more of the structured signal it scores when it decides which offer to surface. That is why fulfillment completeness is a selection lever, not just an operations detail. The more of your terms are legible in-protocol, the fewer reasons an agent has to skip you.
## Why most merchants implement both
Because each rail's confirmed reach points at a *different* engine, the two protocols do not overlap in audience the way competing standards usually do. The practical implication is that ACP and UCP reach additive agent audiences (ChatGPT on one side, the Google surfaces on the other), so for most catalogs the return-maximizing move is to be legible to both rather than to bet a single integration on one ecosystem. 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](/agentic-commerce-optimization/) and the platform pages are about making them actually *do* it.
## 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](/agentic-payment-protocols/), and [AP2](/glossary/#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](https://github.com/agentic-commerce-protocol) (open standard, schema, and reference material). For UCP, start at [Google's UCP developer guide](https://developers.google.com/merchant/ucp), the canonical implementation reference; the [NRF 2026 announcement](https://blog.google/company-news/inside-google/message-ceo/nrf-2026-remarks) 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](/platforms/) and the per-engine pages.