Key takeaways
- UCP and ACP are not two options you pick between: they are the commerce rails for two different agent ecosystems, so the real question is coverage, not which protocol 'wins'.
- ACP (OpenAI + Stripe, September 2025) is checkout-focused and provably powers ChatGPT's Instant Checkout; UCP (Google, NRF, January 2026) spans discovery, checkout, and post-purchase.
- UCP is confirmed as the rail reaching Gemini and Google AI Mode: Google's own developer documentation states that adopting UCP enables agentic actions on both surfaces, starting with direct buying.
- Both already model fulfillment: ACP has carried shipping options since launch and now exposes pickup, delivery windows, and return-policy fields (though returns processing stays with the merchant of record); UCP's post-purchase order tracking and returns support is on Google's roadmap, not yet shipped.
- Neither protocol decides which product an agent picks. Passing either is eligibility, not selection, so implementing both only makes you transactable to more agents. Winning the pick is the separate work this handbook covers.
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 CheckoutSpec-factStripe + OpenAI, Instant Checkout announcement. 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.
| Dimension | ACP: Agentic Commerce Protocol | UCP: Universal Commerce Protocol |
|---|---|---|
| Backed by | OpenAI + Stripe | Google (+ Shopify, Etsy, Wayfair, Target, Walmart, payment partners) |
| Announced | 29 September 2025 | 11 January 2026 (NRF 2026) |
| Scope | Checkout: agent-ready checkout + product feed + delegated payment | Discovery → checkout → post-purchase (post-purchase is roadmap, not yet shipped) |
| Fulfillment options | Modeled since launch; pickup, local delivery, delivery windows and return-policy fields added since | Checkout/Cart capabilities exist; pickup and delivery-window field depth not independently confirmed |
| Returns processing | Return-policy fields shipped since launch; RMA processing stays with the merchant of record | Roadmap only: order tracking and returns are planned, not yet shipped |
| Agent engine reached | ChatGPT: Instant Checkout (confirmed) | Gemini / Google AI Mode (confirmed) |
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. 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.
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 ChatGPTSpec-factStripe + OpenAI, Instant Checkout announcement. 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. The per-engine playbooks live at ChatGPT shopping optimization and Gemini and Google AI Mode ranking, and the shared cross-engine view 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
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 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.
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)(opens in new tab) (open standard, schema, and reference material). For UCP, start at Google's UCP developer guide (opens in new tab)(opens in new tab), the canonical implementation reference; the NRF 2026 announcement (opens in new tab)(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.