The Agentic Commerce Protocol (ACP) is an open standard that lets an AI agent discover a merchant’s products, assemble a cart and place an order through one shared interface — instead of a separate integration for every store and every assistant. It is the layer that turns "an AI can talk about your products" into "an AI can actually buy them for a shopper".
If you have read our broader explainer on agentic commerce, this is the next layer of detail: not the concept, but the mechanism. It is written for a merchant or marketer who wants to understand how ACP works without reading an API specification — precise about what happens, without turning into documentation.
What ACP is, in one sentence
The Agentic Commerce Protocol is a common language for agent-driven buying: it defines how an AI agent reads what you sell and how it submits an order on a shopper’s behalf, so any compliant agent can transact with any compliant store. Think of it the way you think of a payment card network — you do not integrate separately with every bank; you support the network once, and every card works. ACP aims to be that network for AI shopping.
Who created it, and why
ACP was published by OpenAI together with Stripe, and released as an open specification rather than a closed OpenAI feature. That openness is the point. The problem it solves is a combinatorial one: if every AI assistant had to build a bespoke integration with every store or platform, and every store had to do the same in reverse, you would have an unworkable tangle of one-off connections. A shared protocol collapses that into a single standard each side implements once. It is the same logic that gave us email standards and card networks — the value is in everyone agreeing on the same interface.
OpenAI had the most immediate reason to drive it: ChatGPT’s Instant Checkout, which lets a shopper buy inside the conversation, needs a standard way to reach thousands of merchants. Stripe brought the payments half. Because the spec is open, it is not limited to those two companies — which matters for the comparison further down.
How ACP actually works (the mechanism)
It helps to split ACP into three moments: the agent finding your products, the order being handed off, and the payment clearing. Each is a distinct step, and a store can be strong at one and weak at another.
Product discovery — how an agent finds and reads your products
Before an agent can sell your product it has to understand it. ACP relies on a structured product feed: a machine-readable description of each item with its attributes, price, availability and variants. This is not a marketing description — it is the specification data an agent compares against a shopper’s stated need. The cleaner and more complete that data, the more accurately the agent can match you to a query and represent you against competitors. Thin or inconsistent product data is the most common reason a store is technically reachable through ACP yet never surfaced, because the agent cannot confidently tell what the product is.
The transaction handoff — how an order gets placed
Once the shopper decides, the agent needs to place a real order against your store — check the item is in stock, confirm the price, apply any options, and create the order. ACP standardises that handoff so the agent can submit a cart and receive an order confirmation back through the protocol, without a human ever loading your checkout page. Crucially, you remain the merchant of record: the order lands in your system, you fulfil it, and you own the customer relationship and the data. The agent is a channel, not an intermediary that takes the customer from you.
Where payments fit in — Stripe’s role
The payment is the part that has to be both seamless and safe, because a shopper is authorising a purchase they are not clicking through themselves. This is where Stripe’s work sits. Rather than handing the agent raw card details, the model uses a delegated, scoped payment credential — a single-use token that authorises one specific purchase, so the agent never holds reusable card data and neither does the AI model. The merchant gets a normal, verifiable payment; the shopper gets one-step checkout; nobody in the middle is trusted with the card. That separation of "authority to buy this one thing" from "the card itself" is what makes agent-placed orders defensible rather than reckless.
ACP vs Universal Commerce Protocol (UCP) — what’s the difference?
ACP is not the only attempt at this. The comparison people increasingly search for is agentic commerce protocol vs universal commerce protocol — and it is worth taking seriously, even though almost nobody has written it up plainly yet.
The short version: ACP is the OpenAI-and-Stripe standard, currently the one behind ChatGPT’s Instant Checkout. The universal commerce protocol label is used for the Google-aligned approach — a Universal Cart paired with Google’s Agent Payments Protocol (AP2) — aimed at agents on Gemini and Google’s AI surfaces. Both chase the same goal (let an agent buy across many merchants through one interface); they differ in who backs them, which assistants they power today, and some of the payment plumbing underneath.
| ACP | Universal Commerce Protocol / Cart | |
|---|---|---|
| Backed by | OpenAI with Stripe | Google-aligned (Universal Cart + AP2) |
| Powers today | ChatGPT Instant Checkout | Google’s AI shopping surfaces, Gemini |
| Openness | Open specification | Open, with Google’s ecosystem gravity |
| Goal | Agent-driven discovery and checkout | Agent-driven discovery and checkout |
The honest framing for a merchant is that you do not have to pick a winner, and you should be wary of anyone who tells you to. This space is evolving quickly, and some convergence or interoperability between the standards is plausible. What both approaches reward is identical: clean, structured product data, machine-readable policies, and being connected to a checkout path. Do that groundwork and you are prepared for ACP, for the universal-cart approach, and for whatever settles out between them.
Where Shopify fits into ACP
For most merchants reading this, the practical route to ACP is their platform, and Shopify has done more than any other to make that near-turnkey — Shopify Catalog handles the product-discovery feed and Instant Checkout handles the transaction handoff, so a Shopify store can participate without building against the protocol directly. We cover that in depth in Shopify’s agentic commerce features, so we will not repeat it here. The key point for this article is that "supporting ACP" does not have to mean "writing code against the spec" — on a supported platform it can mean configuring what the platform already provides.
What ACP means for you as a merchant
Strip the protocol down to its consequences and three things matter. First, your product data is your storefront in an ACP world — the agent never sees your design, only your feed, so the quality of your structured data decides whether you are surfaced and how accurately you are represented. This is the highest-leverage work, and it is the same work that improves ordinary SEO, so it is rarely wasted.
Second, you do not need to become a protocol expert. Whether ACP is a config task or a build task depends entirely on your platform, and for most merchants it is the former. Chasing the specification yourself is usually the wrong instinct; getting your catalogue data and policies in order is the right one.
Third, watch the economics, not the hype. Agent-driven orders can carry a per-order fee on top of normal payment processing, and that matters more on a thin-margin product than a fat-margin one. ACP does not change who you are as a business; it adds a channel. Model it like any other channel — cost in, revenue out — rather than treating it as a gold rush or a threat.
Frequently asked questions
Is ACP the same as Shopify’s agentic commerce features?
No, but they connect. ACP is the underlying open standard for how any agent discovers products and places orders. Shopify’s agentic commerce features — Catalog and Instant Checkout — are Shopify’s implementation of that capability, so a Shopify merchant can participate in ACP-based buying without touching the protocol directly. ACP is the road; Shopify’s features are the on-ramp.
Do I need to build anything to support ACP?
It depends on your platform. On Shopify, much of it is configuration rather than code — the platform provides the product feed and the checkout handoff. On a custom or headless store you would implement the discovery feed and the order and payment handoff against the specification yourself, or use a service to do it. Either way, the biggest determinant of success is not the integration but the quality of your structured product data.
Is ACP only for OpenAI and ChatGPT, or do other AI platforms use it?
ACP was created by OpenAI with Stripe and currently powers ChatGPT’s Instant Checkout, but it was released as an open specification, so it is not restricted to OpenAI. Other assistants can adopt it. Google is pursuing a parallel approach with its Universal Cart and Agent Payments Protocol, so expect more than one standard in the near term rather than a single universal one.
Want your store ready for this? Our Agentic Storefront Optimization service will get your store ACP-ready — clean product data, machine-readable policies and the checkout wiring — starting with a free Agentic Readiness Audit.