ACP or UCP: How to choose the right protocol for AI agent commerce

Two protocols, two philosophies of how AI agents buy

The fastest way to understand ACP and UCP is to look at the question each one was built to answer.

ACP answers: How does a purchase occur within a conversation? 

The Agentic Commerce Protocol is an open standard under the Apache 2.0 license, originally co-developed by OpenAI and Stripe, with Stripe’s documentation now also crediting Meta as a creator. 

Merchants share a structured product feed so the AI platform can index and display products with current pricing and availability, implement a defined set of checkout endpoints, and receive payment through delegated tokens. 

Stripe’s Shared Payment Token is the first compliant implementation: a scoped credential limited to a specific merchant, amount, and time window. ChatGPT was the first platform to run on it, powering Instant Checkout, and each AI platform manages its own process that businesses can participate in. That’s the philosophy in one line: the platform aggregates demand, and merchants plug into it.

UCP answers a different question: how does any agent transact with any merchant, on any surface, without a central gatekeeper? 

The Universal Commerce Protocol, announced by Google in January 2026 and co-developed with Shopify and a coalition of partners, works more like a web standard than a marketplace. 

Merchants publish a profile at a standard address on their own domain (/.well-known/ucp) declaring which capabilities they support, such as checkout, order management, identity linking, and catalog search. 

Agents discover those capabilities and configure themselves, over REST, JSON-RPC, or Model Context Protocol transports, with payment authorization handled through cryptographic mandates under the Agent Payments Protocol. 

Notably, the spec defines its roles by the direction of capability flow rather than by industry, which makes it equally applicable to B2C, B2B, and agent-to-agent commerce.

Under both protocols, you remain the merchant of record with control over pricing, fulfillment, and customer relationships. What differs is who controls discovery, and that difference drives everything in how the two compare for AI-driven commerce.

ACP vs. UCP: the full side-by-side breakdown

Before you scan the table, a quick note on how to read it. The rows that should drive your decision are architecture, discovery, and the demands each protocol places on your product data. Launch dates and backers make headlines, but they won’t change your integration work. 

Every row below is drawn from the protocols’ official specifications and documentation, current as of this writing; both specs use date-based versioning and are still evolving, so treat this as a snapshot worth rechecking before you commit. 

Before you scan the table, a quick note on how to read it. The rows that should drive your decision are architecture, discovery, and the demands each protocol places on your product data. Launch dates and backers make headlines, but they won’t change your integration work. 

Every row below is drawn from the protocols’ official specifications and documentation, current as of this writing; both specs use date-based versioning and are still evolving, so treat this as a snapshot worth rechecking before you commit. 

Sources: ACP specification (GitHub), agenticcommerce.dev, Stripe ACP documentation, OpenAI commerce documentation, UCP specification (ucp.dev), Google UCP developer guide

The pattern across every row is the same trade. ACP buys you reach into the largest conversational platform with a lighter build, at the price of platform-mediated discovery and feed freshness. UCP buys you an open, live, agent-agnostic storefront on your own infrastructure, at the price of more capable APIs on your side. 

Neither trade is wrong. Which one you make first depends on your demand and your stack, which is where we go next.

The decision isn’t either/or. It’s which one first

Start with the fact that removes most of the pressure: neither protocol locks you out of the other. 

ACP’s official documentation states that any AI platform can implement the spec and any compliant payment provider can process its transactions. Google, for its part, positions UCP as an open, vendor-agnostic standard compatible with existing industry protocols including A2A, AP2, and MCP. 

The ecosystem behaves accordingly: Stripe co-developed ACP and is also listed among more than 20 UCP endorsers in Google’s launch announcement, and Shopify co-developed UCP while supporting merchants on ChatGPT’s ACP-powered checkout. 

Supporting one does not preclude the other, and most merchants with meaningful volume will end up running both. So the real question is sequencing, and two factors should settle it.

• Follow your demand first. Look at where your buyers already let an agent act for them. If your traffic and revenue lean on search intent, buyers who know roughly what they want and go looking for it, UCP puts checkout inside the Google surfaces where that intent already lives.
  
  If your category thrives on conversational discovery, where a question about a problem turns into a product recommendation, ACP puts you inside the dialogue where those decisions happen.
  
  B2B teams should weigh this differently than retailers: procurement-style buying runs on specification and comparison, patterns that mirror the search-intent side, and the AI trends reshaping B2B e-commerce suggest agent-mediated evaluation is arriving there faster than most teams expect.
  
  
• Then be honest about your stack. ACP asks for a product feed, checkout endpoints, and webhooks, a build most commerce teams can scope quickly. UCP asks you to serve live capability endpoints from your own infrastructure, rewarding teams that already run robust APIs and burdening those that don’t.
  
  There’s no prize for choosing the architecturally purer option your systems can’t sustain. An agent hitting a stale feed or a slow endpoint doesn’t wait; it moves to the next candidate, and the way AI recommendations decide which products are chosen makes it clear that reliability is part of the ranking.

Pick the door your demand and your infrastructure both point to, ship it well, and plan the second integration rather than debating it.

Whichever you choose, the agent only sees your product data

Both integration paths, feed or live endpoint, end at the same place: an agent reading your product data and deciding whether your product makes the shortlist. The platforms are already raising the bar on what that data needs to contain. 

Google paired its UCP launch with dozens of new Merchant Center data attributes for conversational commerce, covering answers to common product questions, compatible accessories, and substitutes. Richer, structured product data is the price of being discoverable.

That’s where protocol projects actually stall. The endpoints are a scoped engineering task. The hard problem is that your product data already exists, but AI can’t read it: attributes scattered across ERP, PLM, and spreadsheets, inconsistent identifiers, descriptions written for humans skimming a page rather than agents parsing a schema. An agent evaluating your product against a competitor’s doesn’t weigh your brand story. It compares completeness, accuracy, and freshness, and it drops the candidate with gaps. 

Product information management (PIM) platforms like Inriver exist to close those gaps. PIM is the layer that pulls product data from the systems where it originates, gets it complete and consistent, and delivers it in the shape each channel requires. An agent-facing feed or catalog endpoint is simply the newest channel with the strictest standards.

Inriver’s flexible data model ingests product data from your existing sources as-is, without the usual cleanup or restructuring project first. From there, AI-assisted enrichment closes attribute gaps at scale, with verification and validation applied before anything reaches a channel, whether that’s a retailer portal, an ACP feed, or a UCP endpoint.

The results are measurable: in Inriver’s 2025 AI in PIM study, 62.5% of manufacturers reported improved data accuracy after deploying AI in PIM. Agentic speed, without handing agents data you can’t stand behind.

How do you prepare for ACP and UCP?

You don’t need a protocol strategy document. You need three moves in order:

1. Audit your product data against what agents actually consume. Check attribute completeness, identifier consistency, inventory accuracy, and whether your descriptions answer buyers’ questions.
2. Pick your first protocol using the demand-and-stack test above. Scope the integration as an engineering task with a deadline, not a research project.
3. Fix the data problem before the endpoint problem. A flawless integration serving incomplete data just delivers your gaps to agents faster.

The protocols will continue to evolve; both use date-based versioning, and neither is finished. Your product data foundation is the investment that survives every spec revision.

If you’re ready to make your product data work on both agentic protocols, schedule a personalized demo with Inriver today.