What is the Agentic Commerce Protocol?

The Agentic Commerce Protocol is an open standard codeveloped by OpenAI and Stripe that lets AI agents complete purchases on a buyer's behalf. It defines how an agent finds a product, builds a cart, and submits payment using a Shared Payment Token. The spec is maintained on GitHub and is free to implement on any storefront.

Are Shopify merchants automatically enrolled in ACP?

Most are. Shopify activated Agentic Storefronts for millions of merchants starting in March 2026, which routes Shopify Catalog data into ChatGPT, Microsoft Copilot, AI Mode in Google Search, and Gemini. Merchants manage it from the Shopify admin without a separate integration.

If Shopify auto-enrolled my store, do I still have work to do?

Yes. ACP gets the agent to your catalog. Three things still decide whether the agent can read your product well enough to cite it: a server rendered Schema.org Product block on the page, descriptions written for AI parsing, and a live agent endpoint that returns current price and stock when the agent asks.

What is a Shared Payment Token?

A Shared Payment Token is the payment primitive Stripe built for ACP. It lets an AI agent kick off a charge using the buyer's preferred payment method without seeing the card number. The merchant keeps the customer relationship and the order flows into Shopify like any other sale.

Does ACP only work with Stripe?

No. The Agentic Commerce Protocol is open and works with any payment processor. Stripe codeveloped the spec and ships the first reference implementation, but the GitHub repo is licensed for anyone to build a compatible checkout.

How to Make Your Shopify Store Ready for the Agentic Commerce Protocol

A practical guide to the Agentic Commerce Protocol on Shopify: what it is, what auto-enrolls, and the three fixes that decide whether AI agents can actually buy from your store.

Oeave Team

May 5, 2026

8 min read

How to Make Your Shopify Store Ready for the Agentic Commerce Protocol

If you run a Shopify store and you have noticed that ChatGPT now tries to check buyers out without leaving the chat, you are inside the Agentic Commerce Protocol. The good news is Shopify already enrolled you. The bad news is enrollment alone does not get you cited. Most stores still have product facts buried in JavaScript and no live endpoint for the agent to call. This guide covers what ACP is, what Shopify did automatically, and the three fixes that decide whether your store actually works inside the new flow.

How do you make a Shopify store ready for the Agentic Commerce Protocol?

The Agentic Commerce Protocol is an open standard codeveloped by OpenAI and Stripe for AI-driven checkout. It launched on September 29, 2025, and Shopify began auto-enrolling merchants through Agentic Storefronts in March 2026, with millions of stores activated at once. To be ready, fix three things on top of the auto-enrollment: server-render a Schema.org Product block on every PDP, rewrite descriptions for AI parsing, and ship a live agent endpoint that returns current price and stock. Those three are what decide whether an agent reads your product correctly and cites it.

A sourced fact for the first 150 words: Stripe published the ACP spec on September 29, 2025, the same day OpenAI shipped Instant Checkout in ChatGPT.

What ACP actually is

ACP is a JSON spec that defines three things between an AI agent and a merchant: how the agent finds a product, how it builds a cart, and how it submits payment. The full spec is on GitHub at agentic-commerce-protocol/agentic-commerce-protocol. It is maintained by OpenAI and Stripe and is licensed for any merchant or platform to implement.

The protocol does two things that matter for a Shopify merchant. First, it gives the agent a stable shape to read a product, separate from your storefront's HTML. Second, it gives the agent a way to charge the buyer through a Shared Payment Token, which is a one-time credential the agent holds without ever seeing the card.

The piece most founders miss: ACP does not generate product content. The agent still has to read your page, and your page still has to be readable. ACP is the checkout pipe, not the catalog.

How Shopify auto-enrolled merchants

Shopify activated Agentic Storefronts in March 2026. Shopify's announcement said millions of merchants got out-of-the-box access to ChatGPT, Microsoft Copilot, AI Mode in Google Search, and Gemini, all managed from the Shopify admin.

You did not have to opt in. If you are on a Shopify plan that includes the standard Catalog sync, your products started flowing to ChatGPT and the other AI surfaces automatically. The Shopify Catalog is the data source. ACP is the rail.

You did not get any of these for free:

A Schema.org Product block on the page (Shopify themes vary).
A live agent API endpoint at your own domain.
AI-readable product copy.

Shopify handed the agent your catalog. What the agent finds when it looks at your actual page is on you.

Why most Shopify stores still fail inside ACP

Three failure modes show up on most stores when an AI agent tries to read them.

Price locked inside JavaScript. A theme renders the price block client-side, so the static HTML does not contain a number. The agent sees an empty price slot. Modern Retail reported in March 2026 that OpenAI scaled back parts of Instant Checkout in favor of agentic storefronts, which means the agent reads more, not less, of your page.

No Schema.org Product markup. The agent has no structured way to know what is a price, what is a SKU, what is in stock. It guesses from text and gets it wrong. Schema.org Product is the canonical type and has been since 2011.

Description written for human browsing. Marketing prose, no facts per line, units missing. The agent extracts something, but not the thing the buyer asked about.

These three break the flow even when ACP and the Shopify Catalog sync are working perfectly. The agent gets to your page and cannot read it.

Fix #1: Server-render Schema.org Product

Every PDP needs a JSON-LD Product block in the page HTML, server-rendered, not injected after page load. The minimum viable shape:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Brand X Leather Backpack",
  "sku": "BX-LB-01",
  "image": "https://cdn.shopify.com/...",
  "description": "16 inch leather backpack, full grain, 18L capacity.",
  "brand": { "@type": "Brand", "name": "Brand X" },
  "offers": {
    "@type": "Offer",
    "price": "395.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://yourstore.com/products/leather-backpack"
  }
}

Put it in the head or right after the opening body tag. Validate with Google's Rich Results test before you ship. The full property list is at schema.org/Product.

If you want the longer version of this fix on its own, see Product schema markup for AI search.

Fix #2: Add an agent API endpoint

A static schema block and a daily catalog sync answer most discovery questions. They do not answer the live ones. "Is the small still in stock?" "Does it ship to Norway?" "What is the return window?" An agent that gets a stale answer to those questions stops citing you.

You need an endpoint at your own domain that returns current price, current inventory, variant detail, and policy text in one fetch. The agent calls it during a buyer conversation, gets fresh data, and trusts it.

For Shopify, the endpoint is a thin layer on the Storefront API. Shopify's Storefront API docs cover the GraphQL queries you need. The MCP version is the cleanest shape today: see setting up an MCP server for a Shopify store and what an ecommerce agent API actually returns.

A feed gives the agent a daily snapshot. An endpoint gives it a live answer. The difference between an SEO feed and an agent-readable one goes deeper if you want it.

Fix #3: Rewrite descriptions for AI parsing

A description written for an AI agent reads like spec sheet prose. One fact per sentence. Named units. No filler.

Bad:

Crafted from the finest full-grain leather and built to last a lifetime, this backpack is the perfect companion for the modern traveler.

Good:

Full grain leather. 18L capacity. Fits a 16 inch laptop. 1.4 kg unloaded. Made in Italy. Two-year repair warranty.

The AI agent extracts the second one cleanly. It struggles with the first one because the facts are buried under adjectives. How ChatGPT Shopping picks products covers the same idea from the discovery side: agents reward fact-dense pages over prose-dense ones.

Rewrite your top 10 PDPs first. Those are the ones the agent reaches when a buyer asks for "the best of X under $Y." The rest can follow over a quarter.

A 14-day readiness checklist

This is the order I would run it.

Day 1. Audit your top 10 PDPs in view-source. Check for a Product JSON-LD block and a price string in the static HTML. Note the gaps.
Day 3. Ship Fix #1: server-rendered Schema.org Product on every PDP. Validate with the Rich Results test.
Day 7. Ship Fix #2: a single agent API endpoint at your domain. Even one tool, list_products, is enough to start. Add get_product and create_checkout next.
Day 10. Rewrite your top 10 PDP descriptions. One fact per sentence. Named units. Cut adjectives.
Day 14. Test with a real ACP query. Open ChatGPT, ask for a product in your category in your price range, and see if your store comes up. Ask a follow-up about size or stock and see if the answer is current.

If the answer on day 14 is wrong, the gap is one of the three fixes. Walk back through the checklist.

Where Oeave fits

Oeave is the structured-data layer on top of an ACP-enrolled Shopify store. It server-renders the Schema.org Product block, exposes a live agent endpoint, and turns your existing product copy into AI-readable facts without you replacing your theme. The result is a store the agent reads correctly the first time it gets called. The full AEO playbook covers the broader pattern.

ACP is open. Shopify already plugged your catalog into it. The work that decides whether the agent picks your store is the work on the page.