ACP vs UCP: where agentic checkout protocols stand for stores
ACP vs UCP compared from the specs and operator docs: who maintains each, which AI surfaces use them today, and what a store should check before either matters.
By Crawlito · 9 min read
In short
- UCP is the protocol Google documents for buying directly in AI Mode in Google Search and Gemini, with the merchant remaining the merchant of record.
- Google's UCP checkout covers products sold in the United States and is available to select merchants, and only listings with native_commerce checkout eligibility set to true show the Buy button.
- ACP is a beta specification maintained by OpenAI and Stripe, with date-based versions; the latest stable version was 2026-04-17 at the time of writing.
- OpenAI's commerce docs at the time of writing do not mention ACP; they list product feeds, cloud browser access, ChatGPT Wallet on your own checkout, plugins and Sign in with ChatGPT.
- Both routes depend on the same basics: a product page, a feed and structured data that agree on price and availability, and a site that verified agents can reach.
On this page
The short answer to ACP vs UCP: the Universal Commerce Protocol (UCP) is the one with a documented checkout surface you can join a waitlist for today, through Google's AI Mode and Gemini, for products sold in the US. The Agentic Commerce Protocol (ACP) is an open beta specification from OpenAI and Stripe, but OpenAI's own commerce documentation does not currently describe an ACP integration for ChatGPT. Most stores do not need to build either protocol themselves yet. They need a clean product feed, product pages that match it, and a site that agents can reach.
This post compares the two from their specifications and the operators' documentation, read on 15 November 2026. Both are moving quickly, so treat every status below as true at the time of writing and check the linked pages before you plan work.
ACP vs UCP at a glance
| UCP | ACP | |
|---|---|---|
| Specification | ucp.dev, Apache 2.0 | GitHub repository, Apache 2.0 |
| Who runs it | Listed as co-developed by Google, Shopify, Etsy, Wayfair, Target, Walmart and others; Stripe says it sits on the UCP Tech Council | OpenAI and Stripe, as "Founding Maintainers" |
| Status | Published specification; Google's checkout available to select US merchants | Beta; latest stable version 2026-04-17 |
| Versioning | Date-based (YYYY-MM-DD) | Date-based (YYYY-MM-DD) |
| Transports | REST and JSON-RPC, with MCP, A2A and AP2 support | A traditional HTTP API or MCP |
| Merchant of record | The business | The business |
| Documented consumer surface now | AI Mode in Google Search and Gemini | ChatGPT, per the ACP site; OpenAI's commerce docs do not mention ACP |
| How you start | Merchant Center feed plus Google's waitlist form | Implement the spec; ChatGPT participation needs a separate application, per the ACP site |
The two share a lot. Both keep the store as the seller, both expose checkout as a set of API operations, and both pass a payment token from the agent side to your payment processor rather than raw card details. The practical difference today is where each one actually runs.
What UCP is and how Google uses it
UCP describes itself as a common language for platforms, agents and businesses, covering catalog search, carts, checkout, identity linking through OAuth 2.0 and order updates through webhooks. Each business publishes a profile at /.well-known/ucp listing the capabilities it supports, such as dev.ucp.shopping.checkout, and the business works out which capabilities both sides support, picking the highest version they share. The specification overview documents the negotiation rules.
Google is the main documented consumer. Its UCP page for merchants says merchants can enable agentic actions in AI Mode in Google Search and Gemini, "starting with direct buying". Key points from Google's guides:
- You remain the merchant of record. Google's FAQ says you keep the customer relationship and data, and you are responsible for real-time inventory checks, address validation and your own terms, which shoppers accept at checkout.
- Your existing feed is the entry point. UCP reuses Merchant Center shopping feeds. Only listings with the
native_commerceattribute's checkout eligibility set to true show the Buy button. - Availability is limited. Google's integration guide scopes checkout to products sold in the United States, says onboarding is rolling out gradually and the checkout feature is available for select merchants, and says Australia and Canada will follow.
- Not every product qualifies. Google's Merchant Center preparation guide excludes subscriptions and installments, personalized goods, used, refurbished and final-sale items, pre-orders, freight and other special shipping, age-restricted goods, services, rentals, virtual items and several other categories.
- Ranking is not affected. The FAQ says choosing native integration does not change your ranking in product listings.
The feed side is a small change. Google's attribute reference gives this XML form:
<g:native_commerce>
<g:checkout_eligibility>true</g:checkout_eligibility>
</g:native_commerce>The preparation guide adds a cart eligibility flag to the same group and warns that the whole group is overwritten on every upload, so send every flag each time. It recommends a supplemental data source for these attributes so your primary product data is not disturbed.
Native versus embedded checkout
Google offers two paths:
| Path | What you build | When it fits |
|---|---|---|
| Native (default) | Checkout endpoints that Google calls from AI Mode or Gemini; Google passes a Google Pay payment credential | Standard products with simple checkout logic |
| Embedded (optional) | Your existing web checkout, shown in an iframe or webview inside the host | Products needing logic the native API cannot handle, such as customizations |
The native checkout guide lists five operations:
POST /checkout-sessions
GET /checkout-sessions/{id}
PUT /checkout-sessions/{id}
POST /checkout-sessions/{id}/complete
POST /checkout-sessions/{id}/cancelGoogle sends a tokenized Google Pay credential with risk signals, and you process it through your own payment provider. The FAQ says your provider must be able to process Google's tokens, though you do not need Google Pay on your own site. Google's overview page describes embedded checkout as an optional path for specific, approved merchants, and the embedded guide requires you to declare it in your /.well-known/ucp profile and set frame-ancestors in your Content Security Policy.
What ACP is and where it stands
ACP's repository calls it "an interaction model and open standard for connecting buyers, their AI agents, and businesses". It is in beta, governed by OpenAI and Stripe, and versioned by date. At the time of writing the latest stable release is 2026-04-17, which the repository describes as covering cart, feed, orders, authentication and MCP. The spec ships an OpenAPI definition for the checkout API, a separate one for delegated payment, JSON schemas and a set of RFCs.
The ACP site says businesses publish their checkout through a traditional API or MCP and connect it to their existing commerce backend and payment processor. It names Stripe as the first compatible payment provider through its Shared Payment Token, and says OpenAI is the first AI platform to implement ACP with ChatGPT.
That last point is where you need care. OpenAI's commerce documentation at the time of writing does not mention ACP at all. Its guides list:
- Product feeds, submitted through Business Hub after you claim your business and verify your identity. The feed guide says the feed "does not update a cart or confirm a purchase".
- Cloud browser access, so the browser ChatGPT uses for some tasks can use your existing purchase or booking flow. OpenAI says it requires human review before any consequential action.
- ChatGPT Wallet, a way for customers to pay on your website that works with existing checkout pages and payment forms.
- Plugins, built as an MCP server plus skills, with tools to look up products, check availability and prepare checkout. OpenAI says your MCP server owns availability, pricing, transaction state and confirmation.
- Sign in with ChatGPT and a business profile you claim.
So the ChatGPT paths OpenAI documents today are your existing website and a plugin built on MCP. The plugin guide includes checkout tools, but it does not call them ACP or mention the ACP spec. We cover the feed itself in what merchants can submit to ChatGPT, and browser access in allowing ChatGPT's cloud browser through your WAF. OpenAI's agent access page says signed cloud browser requests use Web Bot Auth with a Signature-Agent value of "https://chatgpt.com", and that an exception for them is separate from OpenAI's crawlers, including OAI-SearchBot.
What platforms handle for you
Most stores will meet these protocols through a platform rather than an integration of their own. Two examples from the documentation:
- Stripe. Its agentic commerce docs describe an Agentic Commerce Suite in which you share a catalog feed and Stripe shares products with agents, manages checkout, processes payment and notifies you of orders. Stripe-managed checkout is available in the US, Canada and select European countries at the time of writing. For stores that run their own UCP checkout, Stripe offers a payment handler.
- Shopify. It is listed among UCP's co-developers. How it exposes stores to AI channels is covered in our post on Shopify agentic storefronts.
Google's integration guide says the same thing in plain terms: if you use a platform or service provider, ask them about their UCP plans before building anything yourself. None of the pages above state fees for UCP or ACP, so ask the platform about costs directly.
Does your store need ACP, UCP or neither yet?
| Your situation | Suggested step |
|---|---|
| US store in Merchant Center with simple, eligible products and an engineering team | Join Google's UCP waitlist and read the native checkout guide |
| Store on a hosted platform | Ask the platform which protocols it supports; do not build your own endpoints first |
| Store hoping to sell inside ChatGPT | Follow OpenAI's documented steps: product feed, cloud browser access, Wallet on your checkout, and a plugin if you have the engineers |
| Subscriptions, custom products or pre-orders | Google excludes these from UCP checkout for now; focus on discovery |
| Developer evaluating ACP | Read the spec and changelog, but note that OpenAI's commerce pages do not mention ACP |
Neither protocol is a discovery or ranking mechanism. Agents still find products through feeds, crawled pages and structured data. Our look at NLWeb and MCP makes the same point for agent endpoints in general.
The checks both depend on
Whichever protocol wins, agentic checkout fails when the data an agent read does not match what your checkout returns. Google's Merchant Center preparation guide recommends sending real-time price and availability updates through the Merchant API or Content API supplemental feeds to prevent price mismatches at checkout. These checks apply to both routes:
- Price and availability agree everywhere. Compare the feed, the visible product page and the Product markup for the same item. Our Product schema guide shows the
offersfields to compare. - Identifiers are stable. Feed IDs should match what your checkout expects. Google offers
merchant_item_idwhen they differ, and OpenAI asks for anitem_idthat is never reused. Add GTIN, MPN and brand where you have them, as covered in GTIN, MPN and brand in Product schema. - Policies are complete. Google requires return cost, return window and a policy link in Merchant Center, plus at least one customer support contact.
- The page is reachable. Product pages should return 200 with the price and availability in the HTML, and your WAF should not block verified agents.
A quick check of the first and last points from the command line:
curl -s -o page.html -w "%{http_code}\n" https://example.com/products/blue-kettle
grep -oE '"price": *"?[0-9.]+' page.html
grep -oE '"availability": *"[^"]*"' page.htmlA non-200 code, or a price that differs from your feed row, is the first thing to fix.
Frequently asked questions
Is UCP the same as ACP?
No. They are separate open specifications with different maintainers, though both keep the business as merchant of record and both expose checkout as API operations. Google documents UCP for AI Mode and Gemini, while OpenAI's commerce docs do not currently mention ACP.
Can I use UCP outside the United States?
Google's integration guide scopes UCP checkout to products sold in the United States at the time of writing, and says Australia and Canada will follow. Check the guide for current countries.
Does adding native_commerce improve my Google ranking?
Google's FAQ says choosing native integration does not influence how Google ranks your offers in product listings. The attribute controls whether the Buy button appears on supported surfaces.
Do I need ACP to sell through ChatGPT?
OpenAI's commerce docs do not mention ACP at the time of writing. They describe product feeds, cloud browser access to your site, ChatGPT Wallet on your existing checkout, and plugins built on MCP.
Who handles orders, support and fraud?
You do. Both protocols keep the business as merchant of record, Google's FAQ makes you responsible for inventory checks and address validation, and OpenAI's Wallet guide says the business handles the order, fulfillment, customer support and fraud decisions.
Start with the pages agents read
Before any checkout protocol, agents need to reach your product pages and read prices and markup that match your feed. Run the free check on a key product page to see what crawlers receive, or ask for an audit if you want every template reviewed with evidence and prioritized fixes.
Filed under Strategy and audits. Topics: ecommerce, ai-agents, ai-search, strategy