Agentic Commerce Protocol: Shopify Technical Guide

In late 2025 OpenAI, Stripe, and a growing list of platform partners began publishing what they call the Agentic Commerce Protocol (ACP) — a set of open conventions that let AI agents discover products, get accurate prices and stock, and complete a purchase without ever loading a human-facing webpage. Microsoft, Shopify, and Adyen have followed with compatible specs. For merchants this is the first real standard for being “sold” by an agent rather than a website.

This guide explains what the protocol actually is at the wire level, how it differs from SEO and structured data, and the concrete changes Shopify merchants need to make to be compliant today.

What the Agentic Commerce Protocol actually is

ACP is not a single document — it's a family of three cooperating specs:

• Product Feed Spec. A canonical JSON or JSON-LD feed describing every SKU an agent can buy: identifier, title, description, price, currency, availability, image, variant axes, shipping options, and return policy. Built on top of schema.org/Product with required extensions for inventory freshness and agent-readable variant resolution.
• Delegated Checkout Spec. A small HTTP API the merchant exposes (typically at /.well-known/acp/checkout) that accepts a signed payment token from the agent platform and returns an order confirmation. Stripe's Shared Payment Token and Shop Pay's agent checkout both implement this.
• Discovery Manifest. A JSON document at /.well-known/agent.json that tells an agent where the feed lives, which checkout endpoints are available, supported currencies, return windows, and rate limits. Think of it as the robots.txt of agentic commerce.

Together these let an agent like ChatGPT's Operator, Microsoft Copilot Actions, or Perplexity's Shopping go from “find me a black leather sofa under $1,500” to a confirmed order in a single API conversation — no scraping, no form-filling, no flaky DOM interactions.

How this differs from traditional SEO

SEO optimizes a page for a human reader who arrives via Google. ACP optimizes a data contract for a machine that never renders your page at all. The differences matter:

• Truth, not ranking. There is no ranking algorithm — agents either trust your feed or they don't. A single stale price kicks you out of consideration for an entire shopping session.
• Freshness windows are explicit. Each price and inventory record carries a validUntil timestamp. Agents will refuse to quote prices older than the merchant's declared TTL.
• Variants must resolve programmatically. “Black, large” has to map to a single buyable SKU without the agent guessing. Free-form swatch images don't count.
• Checkout is delegated, not redirected. The agent never sends the shopper to your site. You have to accept a payment token from the agent platform and fulfill the order against it.
• Auth & trust signals are machine-readable. Return policy, fulfillment SLA, and dispute contact live in the discovery manifest. An agent that can't parse them will de-prioritize you in favor of a merchant who exposes them cleanly.

What Shopify merchants need to add

Shopify already gives you 70% of ACP compliance for free — your products feed, sitemap, and Shop Pay integration cover most of the surface area. The gap is in three specific places.

1. JSON-LD on every product page

Most Shopify themes ship a minimal Product JSON-LD block. ACP requires you to extend it with explicit availability, priceValidUntil, and itemCondition fields, plus a per-variant offers array. Drop this into your theme's product.liquid (or the relevant section file):

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "sku": "{{ product.selected_or_first_available_variant.sku }}",
  "name": "{{ product.title | escape }}",
  "image": [{% for img in product.images %}"{{ img | image_url: width: 1200 }}"{% unless forloop.last %},{% endunless %}{% endfor %}],
  "description": "{{ product.description | strip_html | escape }}",
  "brand": { "@type": "Brand", "name": "{{ product.vendor | escape }}" },
  "offers": [
    {% for variant in product.variants %}
    {
      "@type": "Offer",
      "sku": "{{ variant.sku }}",
      "url": "{{ shop.url }}{{ variant.url }}",
      "price": "{{ variant.price | money_without_currency | strip_html }}",
      "priceCurrency": "{{ cart.currency.iso_code }}",
      "priceValidUntil": "{{ 'now' | date: '%s' | plus: 3600 | date: '%Y-%m-%dT%H:%M:%SZ' }}",
      "availability": "{% if variant.available %}https://schema.org/InStock{% else %}https://schema.org/OutOfStock{% endif %}",
      "itemCondition": "https://schema.org/NewCondition"
    }{% unless forloop.last %},{% endunless %}
    {% endfor %}
  ]
}
</script>

The one-hour priceValidUntil matches the freshness window most agent platforms expect. If your prices are volatile, shorten it to 15 minutes.

2. The discovery manifest

Serve a JSON document at /.well-known/agent.json. On Shopify this means creating a page with handle agent-json, a custom Liquid template that strips theme chrome (see our llms.txt implementation guide for the {% layout none %} pattern), then a URL redirect from /.well-known/agent.json to /pages/agent-json. The content:

{
  "name": "Your Store",
  "url": "https://yourstore.com",
  "version": "acp/0.3",
  "feeds": {
    "products": "https://yourstore.com/products.json",
    "sitemap": "https://yourstore.com/sitemap.xml"
  },
  "checkout": {
    "delegated": "https://yourstore.com/.well-known/acp/checkout",
    "providers": ["shop_pay", "stripe_spt"]
  },
  "currencies": ["USD", "EUR"],
  "shipping": {
    "regions": ["US", "CA", "EU"],
    "sla_business_days": 5
  },
  "returns": {
    "window_days": 30,
    "policy_url": "https://yourstore.com/policies/refund-policy"
  },
  "contact": {
    "support": "mailto:support@yourstore.com"
  }
}

3. Accept a delegated checkout token

On Shopify Plus this is one toggle: enable Shop Pay for AI agents in Settings → Payments → Manage. Shopify then handles the Stripe Shared Payment Token (SPT) exchange on your behalf and writes the order back to your admin like any other channel.

On standard Shopify plans you instead enable ChatGPT Instant Checkout from the same screen — covered in detail in our Instant Checkout guide. The protocol-level mechanics are the same; Instant Checkout is OpenAI's specific implementation of the delegated checkout spec.

Validating compliance

The protocol is new enough that there's no W3C validator yet. Three practical checks:

1. Parse your own JSON-LD. curl -s https://yourstore.com/products/foo | grep -oP '(?<=<script type="application/ld\+json">).*?(?=</script>)' | jq . should return a valid Product object with a populated offers array.
2. Fetch your manifest. curl -s https://yourstore.com/.well-known/agent.json | jq . should return the JSON above with no HTML wrapper.
3. Run a real agent task. Ask ChatGPT (with Shopping enabled) or Perplexity to “buy [your product] from yourstore.com” and watch whether it offers a one-click checkout or falls back to opening your site. Falling back means the protocol layer isn't wired correctly.

Daeri runs all three checks plus 40 others against every store we audit, and tells you which specific protocol field is missing or stale. If you want to know whether your store is ACP-compliant today, run the free audit below.

Where the protocol is heading

Expect three near-term changes: signed feeds (so agents can trust price/stock without re-fetching), standardized return initiation (so an agent can start a return on the shopper's behalf), and cross-merchant cart bundling (one agent checkout that spans multiple stores). Merchants who get the basics right now will pick these up almost for free — the foundation is the same JSON-LD, the same manifest, the same delegated checkout endpoint.

The merchants who'll struggle are the ones still treating agent traffic as “weird Googlebot”. ACP is a different contract. Sign it now and you're ready for whatever the agent platforms ship next.