The way people discover and buy products online is shifting.

Until now, SEO has been about connecting human searchers with websites through keyword targeting, structured data and user experience.

With the rise of AI agents, discovery and transactions are no longer limited to search engines or traditional eCommerce funnels. Agents such as ChatGPT can now handle entire shopping journeys from search to checkout inside the conversation.

OpenAI’s Agentic Commerce Protocol (ACP) is at the centre of this change.

ACP provides a standard for merchants to expose their product data, pricing, availability and checkout flows directly to AI agents. This allows products to be discovered, compared and purchased without the user visiting a website in the traditional sense.

For SEOs this represents both a challenge and an opportunity, especially those working with the Shopify platform.

If your product data is not structured, accessible and agent friendly, your brand risks being invisible in these new commerce flows. The opportunity is that by understanding and implementing ACP, SEOs can expand their role into a new discipline called Agentic SEO.

This means optimising not just for search engines but for AI agents that act as buyers.

I’ve spent a few hours going through the documentation, and with this article I aim to walk through the technical aspects of ACP and translate them into practical steps for SEO and digital commerce teams.

Key concepts & architecture

What ACP is and why it matters

The Agentic Commerce Protocol is an open standard that allows AI agents such as ChatGPT to interact with merchants in order to show, compare and sell products.

Rather than relying only on traditional web pages, ACP makes it possible for an agent to access structured data feeds and transactional APIs directly. This ensures that product information, stock levels and pricing are accurate and kept up to date.

For businesses the significance is clear.

A well implemented ACP integration means that their products can be surfaced inside AI powered conversations, while payments and fulfilment remain under the merchant’s control. For SEO teams this marks a shift away from optimising purely for search results pages and towards ensuring that product data is structured, accessible and agent ready.

How ACP works in practice

The protocol brings together three main elements that must be understood.

  • Product feed. This is where product data is exposed in a structured format so that AI agents can read, interpret and rank items for discovery.
  • Checkout integration. Agents initiate and update checkout sessions through defined endpoints that connect directly with the merchant’s systems. The merchant validates cart details, stock and pricing before returning a session state to the agent.
  • Delegated payment. Secure payment tokens are exchanged between the agent, the merchant and payment service providers. This allows the agent to complete a purchase without ever holding sensitive card details.

High-level flow

Here’s an abstract of the end-to-end flow:

  1. Product feed ingestion & indexing. You provide a feed or API endpoint that includes structured product data (IDs, titles, descriptions, price, inventory, media, shipping, etc.). ChatGPT consumes this, validates, indexes, and uses it during “shopping queries.”
  2. Query/Discovery. A user asks ChatGPT for a product > ChatGPT uses its product index to find matching products (from your feed and others), ranks them, and shows results.
  3. Agent/user initiates checkout. If “Instant Checkout” is enabled, the UI will allow “Buy” directly from ChatGPT. ChatGPT collects the buyer’s preference, shipping address, payment method, etc.
  4. Checkout session management. ChatGPT calls your merchant backend via the Agentic Checkout Spec to create, update, or complete a checkout session. You must respond with authoritative cart/line item/shipping/pricing state, validate the request, and accept or decline.
  5. Delegated Payment (if used). ChatGPT may call your PSP (or delegated payment API) to request a secure token (with constraints, maximum amount, expiration). The merchant’s PSP returns a token, which ChatGPT forwards to you in the complete call.
  6. Fulfillment, order events. You send webhooks (e.g., order_created, order_updated) so ChatGPT (and ultimately the agent/UI) remains synchronized with the order lifecycle.
  7. Post-purchase, returns, support. Those remain your responsibility. Merchant retains full control over returns, support, refunds, etc.

From an SEO view, the Product Feed is akin to your agent-facing sitemap & structured data. The Checkout endpoints are your agent-facing transactional APIs.

How merchants are selected

Product results are selected independently by ChatGPT and are not ads, nor influenced by any OpenAI partnerships.

Previously, OpenAI stated that the order in which they display merchants was predominantly determined by providers and that they did not re-rank merchants.

Now they specify that the list is generated by ChatGPT based on merchant and product metadata from third-party providers or directly from merchants themselves.

Merchants are ranked based on factors such as availability, price, quality, whether they are the maker or primary seller of that item, and whether Instant Checkout is enabled.

OpenAI also mention plans to evolve this further by personalising merchant rankings to user preferences.

Product surfacing and data sources

When determining which products to surface, ChatGPT now considers structured metadata from first-party and third-party providers (for example price, product description) and other third-party content.

Pricing updates

ChatGPT works to highlight the lowest priced option it is aware of with the label “Best price” in the product detail page and merchant rankings.

Product reviews

Reviews and ratings are still not verified by OpenAI.

When merchants update their pricing or shipping terms, there may be some delay before this is reflected in the information displayed. OpenAI has stated that they are actively working on faster methods to update this information.

ACP is supported within ChatGPT, where it powers Instant Checkout for selected merchants.

The expectation is that adoption will expand over time to other AI agents and platforms that want to enable commerce in conversational settings. Merchants preparing their systems now will be better placed as support broadens across the ecosystem.

Technical integration and SEO considerations

Product feed specification

The feed looks to be the most important element for SEO teams (from the version one documentation).

It functions like a sitemap for agents, containing fields for product identifiers, titles, descriptions, pricing, inventory, shipping options and media. OpenAI requires that the feed is delivered in a supported format such as JSON, CSV, TSV or XML, and that it is refreshed regularly to avoid staleness.

From an SEO perspective, the richer the feed the better. Providing optional fields such as reviews, ratings and variant information increases the chances of a product being selected by an agent.

If prices or availability differ between the feed and your transactional backend, agents may reject your products altogether. SEOs should work closely with developers to ensure feeds are stable, updated at least every fifteen minutes and include consistent identifiers for each product.

Checkout integration

Once a user has selected a product, ChatGPT calls the merchant’s API endpoints to create and manage a checkout session.

The merchant must confirm stock, apply taxes and shipping costs, and return a clear cart state. This flow relies on idempotency and signature verification so that sessions cannot be replayed or tampered with.

For SEOs, the checkout stage may feel outside their usual remit, but its performance has a direct effect on visibility. If an agent detects repeated errors, slow responses or inconsistent pricing, it may downrank or stop surfacing the affected products. Collaboration between SEO and engineering is vital so that the checkout process is smooth and reliable.

Delegated payment

To complete the transaction, payment tokens are exchanged through a delegated system. This prevents the agent from storing sensitive card data while still enabling instant purchase. Merchants can either integrate directly with a payment provider or use Stripe’s shared token approach. In both cases, any failure or error here damages trust and conversion rates.

SEOs should recognise that while this step is technical, it links back to agentic reputation. Agents may prefer merchants that consistently succeed in completing transactions without errors. This potentially makes payment reliability a “ranking factor” in this process.

Technical integration is therefore not only about enabling transactions.

It is potentially a new of SEO work that we need to expand into (not a new practice altogether), where data quality, reliability and transparency directly affect how and when products are surfaced in AI driven commerce flows.

Pseudocode

The following code is provided in pseudocode rather than production ready form.

It should be read as a guide to logic and sequence, not copied directly into a live system. Developers will need to adapt the examples into their own environment with proper security, validation and error handling in place.

JSON

{
"products": [
{
"id": "SKU12345",
"title": "Trail Runner Pro Shoes",
"description": "Lightweight trail running shoes with waterproof membrane.",
"enable_search": "true",
"enable_checkout": "true",
"gtin": "0123456789012",
"price": "129.99",
"currency": "USD",
"inventory": {
"available": 42,
"status": "in_stock"
},
"media": [
{ "type": "image", "url": "https://example.com/img1.jpg" },
{ "type": "image", "url": "https://example.com/img2.jpg" }
],
"shipping": {
"options": [
{ "id": "standard", "label": "Standard", "price": "5.00", "duration": "5-7 days" },
{ "id": "express", "label": "Express", "price": "15.00", "duration": "2-3 days" }
]
},
"rating": {
"average": 4.7,
"count": 120
}
// Other variant, category, tax, etc fields
}
]
}

Python-esque

def create_checkout_session(user, cart_items, shipping_address=None):
payload = {
"buyer": {
"id": user.id,
"locale": user.locale
},
"items": [
{"id": sku, "quantity": qty} for sku, qty in cart_items.items()
],
"shipping_address": shipping_address
}
headers = get_spec_headers()
resp = requests.post(
MERCHANT_BASE + "/checkout_sessions",
json=payload,
headers=headers
)
# validate signature, status 201, parse returned session
return resp.json()

def complete_checkout(session_id, payment_token=None):
payload = {
"payment": { "token": payment_token } if payment_token else None
}
headers = get_spec_headers()
resp = requests.post(
MERCHANT_BASE + f"/checkout_sessions/{session_id}/complete",
json=payload,
headers=headers
)
return resp.json()

You’ll need to follow the spec’s rules around response structure, error codes, idempotency, and webhooks.

Potential challenges

Integrating ACP will not be without challenges.

Based on my experience in eCommerce, feed management, and how wonderful Google Merchant Center can be, the following are things I’d be looking out for to ensure

Data consistency

If product data in the feed does not match the data returned by the checkout API, agents may stop showing those products. Consistency across all layers is essential.

Feed staleness

Agents appear to rely on near real time accuracy. If your feed is updated too slowly, pricing or stock may be out of date and lead to user frustration or reduced visibility.

Latency and timeouts

Slow API responses can cause agents to drop a merchant in favour of faster competitors. Performance is as important here as it is in traditional SEO.

Security and validation

Each endpoint must implement signature verification, idempotent operations, and error handling. Weak security could lead to replay attacks or invalid transactions.

Payment failures

Unreliable payment integration not only prevents conversion but also damages trust signals. Frequent failures may cause agents to avoid recommending your store.

Identifier stability

Product identifiers that change too often disrupt continuity and may prevent agents from indexing your catalogue effectively.

Version compatibility

As the protocol evolves, merchants must keep their integrations updated. Failing to support newer API versions risks exclusion from future commerce flows.

Over optimisation

Attempts to game the system with misleading feed data or artificial scarcity can backfire. Agents may deprioritise merchants that are not transparent or reliable.

Agent diversity

Different AI agents may interpret data slightly differently. Merchants should test across multiple environments and ensure resilience to variations in implementation.

How this changes your SEO and Agentic SEO strategy

Agentic commerce changes the goals and methods of SEO.

Traditional practices such as keyword optimisation and link building still matter for human users, but for agents the priority is data quality and accessibility. Product feeds act as the new discovery layer, so SEOs must treat them with the same importance as site content.

Checkout and payment reliability also become indirect ranking factors, since agents will avoid merchants that deliver poor or inconsistent experiences.

If AI search is on your roadmap, don’t go it alone. Connect with experts who know how to make it work for eCommerce.