What Is the Agentic Commerce Protocol (ACP)?
The Agentic Commerce Protocol (ACP) is an open standard from OpenAI and Stripe that lets an AI agent like ChatGPT complete a purchase directly inside the chat — using a structured product feed, a checkout API, and a single-use payment token that never exposes the shopper's card number to the agent.
What Is the Agentic Commerce Protocol?
The Agentic Commerce Protocol (ACP) is an open standard, built by OpenAI and Stripe, that lets an AI agent — like ChatGPT — complete a purchase on a merchant's behalf inside the chat itself, instead of linking out to a website. It gives a product catalog, a checkout flow, and a payment authorization a shared format so any AI agent can act on them consistently.
Think of it as the plumbing behind "buy it right here in ChatGPT." Before ACP, an assistant that wanted in-chat checkout needed a custom integration with every merchant platform. ACP tries to solve that once — the way schema.org solved "describe a product so any search engine understands it" for the open web.
Two things separate it from a rebranded "buy button" plugin:
- It's open, not exclusive to ChatGPT. OpenAI and Stripe published ACP as a spec any platform can adopt, not a private API that locks merchants into one assistant.
- It's built for agents reading data, not humans clicking pages. The "shopper" reading your product feed might be a model deciding what to recommend and buy — not a person scrolling on a phone.
If you sell on Shopify, ACP is why "can an AI agent actually read my catalog" just became a practical question instead of a hypothetical one.
Why Did OpenAI and Stripe Build It?
They built ACP to close the gap between an assistant recommending a product and actually completing the sale. Assistants could already browse and describe products — they had no standard way to finish the transaction without bouncing the shopper to a browser tab.
Every AI shopping assistant hits the same wall: it can tell a user "this looks like the best fit," but the moment someone says "buy it," the conversation historically broke — handed off to a separate checkout page. That handoff is a conversion leak; every extra click costs merchants sales. OpenAI has framed commerce inside ChatGPT as removing that friction so the transaction finishes where the conversation already is.
Stripe's role is payments infrastructure, not recommendation logic. ACP defines how a merchant's checkout and a payment processor exchange a secure, single-use authorization — so an agent can trigger a real charge without ever holding the card number. That security boundary is what merchants should care about most, covered next. (For the wider discovery layer this sits on top of, see answer engine optimization for Shopify.)
How ACP Actually Works
ACP connects three pieces — a structured product feed, a checkout API, and a delegated payment token — so an agent can find a product, start a checkout session, and complete payment without the merchant ever handing raw card data to the agent.
- Product feed. The merchant exposes a structured feed of its catalog — items, prices, availability, variants — in a format the agent can parse. Conceptually similar to a Google Merchant Center feed, but built for agent retrieval rather than ad placement.
- Checkout session. When a shopper says "buy the medium in blue," the agent calls the merchant's checkout API to create an order — quantity, variant, shipping, and total confirm back before anything is charged.
- Delegated payment token. Instead of the agent seeing or storing a card number, Stripe issues a single-use credential scoped to that exact order. The agent passes this token to authorize the charge; it can't be reused and never exposes card details to OpenAI.
- Order confirmation and fulfillment. The merchant's own systems process the order exactly as they would for any other checkout. ACP doesn't touch shipping, returns, or customer service — that stays with the merchant.
The delegated-token design is the detail worth sitting with. The merchant, not OpenAI, still owns the customer relationship, the payment processing, and the fulfillment — the agent initiates checkout but never holds funds or becomes a middleman. That's meaningfully different from a marketplace model that takes a cut and controls the transaction end-to-end.
ACP vs. a Traditional Ecommerce Checkout
A traditional checkout assumes a human clicks through your site. ACP assumes an AI agent reads your feed and triggers checkout for a human who never leaves the chat.
| Traditional Shopify Checkout | Agentic Commerce Protocol | |
|---|---|---|
| Who initiates the purchase | Shopper clicks "Add to Cart" | Shopper tells an agent to buy; the agent calls your checkout |
| Where it happens | On your website | Inside the AI assistant (e.g., ChatGPT) |
| What the "shopper" reads first | Your product page copy and images | Your structured product feed |
| Card data flow | Shopper enters card at your checkout | Stripe issues a single-use token; no card number reaches the agent |
| Who owns fulfillment | You, always | You, always — ACP doesn't change this |
| Integration effort | Native to your storefront | Requires an ACP-compatible feed and checkout endpoint |
The row that matters most for deciding whether to care: you still own fulfillment, refunds, and the customer relationship. ACP changes how a transaction is triggered, not who's responsible for the order afterward.
What ChatGPT Instant Checkout Has to Do With ACP
ChatGPT's Instant Checkout is the first consumer-facing product built on ACP — the visible tip of the protocol. If you've seen a "buy directly in ChatGPT" headline, ACP is doing the work behind it.
OpenAI has said Instant Checkout started with a small set of merchants and has been expanding since, with Shopify named as one of the platforms enabling merchants to participate. Eligibility, rollout region, and qualifying categories have moved since launch, so treat any specific merchant count as a snapshot — check OpenAI's own updates before planning around a number.
For what "showing up" in ChatGPT actually requires beyond checkout mechanics — feed quality, product schema, review data — see how to show up on ChatGPT.
PayPal, Google, and Who Else Is Involved
ACP is OpenAI and Stripe's protocol, but it isn't the only agentic-checkout infrastructure emerging in 2025–2026. Treat everything below as current, not settled — this space is consolidating in real time, and any article, including this one, describes a snapshot.
- PayPal. OpenAI has announced PayPal as a payment method for ChatGPT purchases, alongside Stripe-processed checkout. Whether it sits on top of ACP or runs a parallel path is worth confirming directly with OpenAI's official announcements rather than assuming.
- Google. Google has its own agent-commerce initiative, sometimes discussed alongside the term "Agent Payments Protocol" (AP2), backed by a coalition that has included payment networks. It's a separate effort, not a competing implementation of ACP — the two solve overlapping problems with different backers, per Google's developer documentation on AI features.
- Merchant platforms. Shopify has been the most visible ecommerce platform enabling ACP-based checkout, but because the protocol is open, other platforms can build support too.
If a specific partnership detail matters to a decision you're making, verify it against the primary source first.
What This Means for Your Shopify Store
For most Shopify stores, ACP changes what "being crawlable" means — less about doing something today, more about your product data already being in a shape an agent can act on when it reaches you.
- Get your basic Product structured data right first. ACP-style feeds and AI retrieval both depend on the same signal: clean Product schema — name, price, availability, variants, SKU. If this is missing, the checkout protocol behind it doesn't matter. See adding product schema on Shopify.
- Make your reviews structured, not just displayed. An agent deciding what to recommend — before any checkout happens — leans on machine-readable ratings, not a JavaScript star widget. See adding review schema on Shopify.
- Don't chase ACP integration before fixing discoverability. Being checkout-ready means nothing if an agent never surfaces your product — citation comes before checkout in the funnel.
- Watch for Shopify's own tooling, not third-party plugins claiming "ACP compliance." Since Shopify has been named as an enabling platform, official documentation beats a bolt-on plugin.
- Treat this as infrastructure, not a marketing channel. It only speeds up the last step once agents are already citing and recommending you — it doesn't create that citation on its own.
Where StoreCited Fits
ACP handles the checkout handoff once an agent has already decided to recommend your product — it does nothing if the agent never mentions your store. That earlier step, whether ChatGPT, Perplexity, or Google's AI Overviews cite you, is the actual bottleneck for most Shopify stores today.
A free AI Visibility Score scan checks exactly that layer: structured data gaps, the competitors AI is citing instead of you, and the fixes to close it. No plugin — including ours — promises a guaranteed spot in ChatGPT. What we check is whether your store gives an AI agent anything solid to cite in the first place, covered in more depth in structured data for Shopify.
Get the answer for your specific store