What Is Agentic Checkout? How ACP, UCP, and Universal Checkout Compare
Arjun Bhargava
Co-founder and CEO @ Rye
10 minutes read
What is agentic checkout? Compare ACP vs. UCP protocols, understand the universal checkout gap, and learn which integration path fits your AI product.
TL;DR / Key Takeaways
Agentic checkout is the transaction execution layer of agentic commerce — the specific mechanism by which an AI agent completes a purchase inside an AI interface without redirecting to a merchant’s website.
Two protocols are trying to standardize how this works: OpenAI’s Agentic Commerce Protocol (ACP) handles checkout transactions via Stripe’s Shared Payment Token, while Google’s Universal Commerce Protocol (UCP) covers the full shopping journey with credential-provider-based payments.
Both protocols require merchant opt-in — and after OpenAI scaled back native checkout in ChatGPT with only roughly a dozen merchants live, the coverage gap is now the central challenge.
The market is converging on three checkout architectures: protocol-based (ACP/UCP), curated marketplace, and universal checkout via agentic browser automation. Of these, only universal checkout is truly agentic — an AI agent autonomously navigating a merchant’s checkout flow and completing a transaction without any merchant-side technical integration or lift.
Most production AI agents will need to layer multiple approaches: protocol-based checkout for opted-in merchants, universal checkout for everything else.
Agentic checkout is how AI agents complete purchases — but every major platform implements it differently, covers different merchants, and makes different tradeoffs. The architectural choices matter: they determine which products your agent can actually buy, how payment data flows, and what happens when a merchant hasn’t opted in to any protocol.
This piece explains what agentic checkout is, compares the two leading protocols head-to-head, and maps the three competing architectures developers are choosing between today. For background on the broader market — what agentic commerce is and where it stands — see our guide to agentic commerce.
The timing could not be more important. In March 2026, OpenAI scaled back native checkout in ChatGPT after only roughly a dozen Shopify merchants went live — shifting to app-based checkout through Instacart, Target, and Expedia instead. The pullback didn’t signal that agentic checkout is failing. It revealed which checkout architectures can actually scale — and which can’t.
What Is Agentic Checkout?
Agentic checkout is the specific mechanism by which an AI agent completes a purchase: handling payment, shipping selection, tax calculation, and order confirmation on behalf of the user, without redirecting them to a merchant's website.
It's related to but distinct from native checkout — which refers to completing a purchase inside an AI chat interface. Native checkout can be agentic (an agent autonomously navigating a merchant's checkout flow), but it isn't always — it can also be a simple embedded checkout widget with no agent involved. Agentic checkout is the broader term: any checkout completed through an agentic workflow, whether that happens inside a chat UI, a background agent, or a developer's own application.
It’s distinct from the broader concept of agentic commerce, which encompasses discovery, comparison, and post-purchase support. Agentic checkout is narrower: it’s the transaction execution layer. The moment an agent goes from “here’s what I found” to “here’s your order confirmation.”
The general pattern works like this: a user describes what they want. The AI agent identifies a product. The user confirms. Payment is processed through a tokenized method — the merchant never sees raw card data, and the user never leaves the conversation. The merchant fulfills the order. The agent relays confirmation and tracking.
That pattern sounds simple. The engineering underneath — and the question of which merchants it works with — is where the three competing architectures diverge.
The Protocol Layer: ACP vs. UCP
Two protocols are trying to standardize how AI agents interact with merchants during checkout — part of a broader protocol stack that includes MCP, A2A, and Visa TAP. The two most relevant to checkout specifically are ACP and UCP, and understanding how they diverge matters for anyone building in this space.
ACP (Agentic Commerce Protocol)
OpenAI and Stripe co-developed ACP as an open-source standard under the Apache 2.0 license. ACP defines how an AI agent communicates with a merchant’s backend to create a checkout session, exchange buyer details, and process payment. Stripe’s Shared Payment Token handles the payment layer — a delegated payment mechanism where OpenAI prepares a one-time payment request with a maximum chargeable amount, and the merchant’s payment service provider processes the transaction.
ACP launched with Instant Checkout in ChatGPT — initially with Etsy merchants and a pipeline of Shopify sellers. PayPal adopted ACP in late 2025, and Stripe’s Agentic Commerce Suite has since rolled out integrations through Wix, WooCommerce, BigCommerce, Squarespace, and others. The spec has been updated multiple times, most recently in January 2026 with support for extensions, discounts, and additional payment handlers.
Following OpenAI’s pivot to app-based checkout, ACP now primarily powers transactions through dedicated retailer apps within ChatGPT — Instacart, Target, DoorDash — rather than broad product-listing checkout.
UCP (Universal Commerce Protocol)
Google and Shopify co-developed UCP, announced at NRF 2026. The core divergence from ACP: where ACP is built for a single checkout transaction, UCP models the entire commerce lifecycle — from product discovery to purchase to post-purchase support like returns and tracking. It establishes a common language for AI agents across surfaces, not just a single platform.
UCP uses a different payment architecture: instead of a single payment processor, it supports flexible payment handlers. Merchants advertise which payment methods they accept, credential providers tokenize payment and identity information, and the agent negotiates per transaction. Google’s Agent Payments Protocol (AP2) works alongside UCP to handle the payment authorization layer, with support from Visa, Mastercard, and PayPal.
The UCP partner coalition includes over 20 companies: Shopify, Etsy, Target, Walmart, Wayfair, Best Buy, Visa, Mastercard, American Express, Adyen, Stripe, Macy’s, Home Depot, Flipkart, and Zalando, among others. As of early 2026, UCP-powered checkout is live with Etsy and Wayfair on Google AI Mode and the Gemini app, with Shopify, Target, and Walmart integrations upcoming.
Head-to-Head: How They Differ
The protocols are more complementary than competing, but the architectural differences have practical implications:
Scope. ACP is checkout-focused — it handles the transaction. UCP covers the full commerce lifecycle: discovery, checkout, fulfillment, returns. For developers building end-to-end shopping experiences, UCP provides more primitives. ACP is narrower in scope, though both still require meaningful merchant-side integration work.
Payment handling. ACP routes through Stripe’s Shared Payment Token with a single delegated payment flow. UCP supports multiple payment handlers per transaction — the merchant and agent negotiate dynamically based on cart, location, and buyer preference.
Platform reach. ACP powers transactions within the ChatGPT ecosystem. UCP is surface-agnostic by design and currently live across Google AI Mode and Gemini, with compatibility for A2A and MCP transports.
Merchant onboarding. For Shopify and Etsy merchants, both protocols offer relatively streamlined onboarding — Shopify merchants can enable UCP from their admin dashboard, and Etsy supports both protocols. For other merchants, both require implementing the respective spec and providing structured product data.
What they share. Both are open-source. Both use tokenized payment flows where the AI agent never handles raw card data. Both keep the merchant as the merchant of record — responsible for fulfillment, chargebacks, and customer relationships. And both require merchant opt-in.
That last point — merchant opt-in — is the setup for the structural problem neither protocol solves alone.
The Coverage Gap: Why Universal Checkout Matters
Both ACP and UCP require merchants to opt in — implement the spec, connect their commerce backend, and maintain structured product feeds. That’s a reasonable requirement for enterprise retailers with engineering teams. But what happens when protocol adoption stalls?
OpenAI’s experience answered that question concretely. Even with Shopify as a distribution partner — handling the technical integration for its merchants — only roughly a dozen went live with ChatGPT checkout before OpenAI pulled back to app-based purchasing. Shopify’s president confirmed the bottleneck was on the AI firms’ side, not the merchants’. If the largest AI platform and the largest commerce platform together couldn’t scale protocol adoption past a handful of sellers, the coverage gap between protocol-enabled merchants and the broader web isn’t closing anytime soon.
This creates a practical problem for developers: shopping intent doesn’t follow protocol boundaries. A user asks an agent to find a specific product. The best option might be on a store that hasn’t adopted any protocol — and the agent can find it but can’t buy it.
Amazon recognized the gap early. “Buy for Me” uses browser automation to navigate third-party merchant sites and complete purchases without merchant integration, expanding from 65,000 to over 500,000 products. The approach works, but it raised consent questions from retailers who discovered Amazon was purchasing from their stores without opt-in.
The tension is clear: protocols require merchant adoption to scale — and adoption means technical integration, engineering resources, compliance review, and for larger enterprises, legal sign-off. That process takes months to years. Browser-based approaches work immediately but need sophisticated fraud mitigation and reliability engineering.
Three Architectures for Agentic Checkout
The market is converging on three distinct approaches. Each makes different tradeoffs between coverage, reliability, and integration effort.
Protocol-based checkout (ACP, UCP) offers the cleanest integration model. The merchant provides a structured API. Payment, fulfillment, and order management flow through the merchant’s existing systems. Structured error states, real-time inventory, and clean order lifecycle management come built in. The limitation is coverage — it only works with merchants who’ve implemented the protocol.
Curated marketplace checkout uses partnerships with specific merchants and payment processors. Perplexity’s PayPal-powered checkout supports thousands of merchants with a polished in-chat experience. The selection is high-quality within the network but constrained by partnership agreements.
Universal checkout via agentic browser automation works with any merchant by operating at the browser layer rather than requiring API integration. A product URL and tokenized payment method go in; an order confirmation comes out. Rye’s Universal Checkout API provides this as an agentic checkout API — enabling any AI agent to purchase from any online store without merchant opt-in, already proven in production. The tradeoffs inherent in this approach — fraud mitigation against merchant bot-detection systems, reliability engineering across variable checkout flows, and handling live page changes — are managed by the universal checkout provider, not the developer integrating the API.
Each architecture has a role — but the calculus is shifting. Even large retailers are waiting on the same thing before investing in protocol adoption: meaningful volume of agentic transactions and consumer adoption of the channel. Universal checkout lets merchants participate in agentic commerce today without that upfront investment, which is why it’s the only path to actual coverage across the breadth of online retail.
The practical insight for developers: most production agents will layer multiple approaches. Protocol-based checkout for opted-in merchants, universal checkout for everything else.
Three Architectures for Agentic Checkout: Protocol-based approaches (ACP, UCP) offer clean integrations but limited coverage. Curated marketplaces expand reach through partnerships. Universal checkout via browser automation enables any-merchant coverage — and most production agents will layer all three.
What Developers Should Know
If you’re building an AI product that needs to complete purchases, the choice depends on your coverage requirements and target ecosystem.
Choose ACP when you’re building within the ChatGPT ecosystem and your merchants are already opted in via Shopify, Etsy, or Stripe’s Agentic Commerce Suite. ACP gives you structured checkout transactions with clean payment delegation. Start with OpenAI’s developer documentation.
Choose UCP when you’re building on Google’s ecosystem or need full-journey primitives beyond checkout — discovery, fulfillment tracking, returns. UCP’s surface-agnostic design also makes it relevant for multi-platform agents. Start with Google’s UCP documentation.
Choose universal checkout when your use case requires purchasing from any merchant — including the vast majority that haven’t implemented any protocol. This is essential for long-tail coverage and for agents that need to be truly merchant-agnostic. Rye’s API documentation covers the integration path.
The layered approach is what most production agents will converge on: protocol-based checkout where available, universal checkout as the fallback layer. This gives you the clean integration benefits of ACP and UCP for major retailers, with full merchant coverage for everything else. For a deeper look at infrastructure trade-offs and the implementation path, see our guide to building AI commerce agents.
Frequently Asked Questions
What’s the difference between agentic checkout and agentic commerce?
Agentic commerce is the full cycle — an AI agent discovering products, comparing options, applying user preferences, completing a purchase, and handling post-purchase support. Agentic checkout is one layer within that: the specific transaction execution mechanism that handles payment, shipping, tax, and order confirmation. Think of agentic commerce as the journey and agentic checkout as the cash register. For the full picture, see our guide to agentic commerce.
Do I need to integrate ACP, UCP, or both?
It depends on your distribution surface and coverage requirements. If your agent lives in ChatGPT, ACP gives you access to opted-in merchants. If you’re on Google surfaces or want full-journey primitives, UCP is the path. Many production agents will integrate both — and layer in universal checkout infrastructure for the merchants that neither protocol reaches. Etsy, notably, supports both ACP and UCP simultaneously.
Is agentic checkout secure? Who handles payment data?
Both protocols use tokenized payment flows — the AI agent never sees raw card numbers. In ACP, Stripe’s Shared Payment Token creates a one-time delegated payment request with a capped amount. In UCP, credential providers tokenize payment and identity information separately from the agent, and AP2 handles authorization. Universal checkout approaches similarly use tokenized payment methods. In all three models, the merchant remains the merchant of record — retaining responsibility for fulfillment, chargebacks, and disputes. For more on the security architecture, see our analysis of tokenization and security in agentic commerce.
What happens when an agentic checkout fails?
Protocol-based systems (ACP, UCP) return structured error states because the merchant’s API communicates stock and pricing in real time. Browser-automation systems handle failures through retry logic and fallback workflows — monitoring for out-of-stock items, price changes, and checkout flow variations. For an analysis of reliability patterns and performance benchmarks across checkout approaches, see our piece on checkout latency and agent adoption.
Can an AI agent buy from any online store today?
It depends on which checkout architecture you're using. Protocol-based checkout (ACP, UCP) covers opted-in merchants — a growing but still small fraction of online retail. After OpenAI scaled back native checkout with only roughly a dozen Shopify merchants live, protocol coverage remains concentrated among large retailers who've committed engineering resources to integration. Curated marketplace checkout (like Perplexity's PayPal partnership) covers partner merchants within a specific network. Universal checkout via agentic browser automation is the only current path to true "any store" coverage — it works with any merchant's existing checkout flow without requiring protocol adoption. Most production agents will layer multiple approaches: protocol-based for large opted-in retailers, universal checkout for everything else. The tradeoff is that browser-automation approaches require dedicated fraud detection for agent transactions, since merchant systems are designed to block exactly this kind of automated purchasing.
Start Building
Rye's Universal Checkout API gives your AI agent universal coverage — protocol-based merchants, curated marketplaces, and the full long tail of the web. Get your API key and start building in minutes.
For broader context on the market, see our guide to agentic commerce.
Product
Resources