how do i make my product catalog discoverable to ai shopping agents

Short answer: AI shopping agents don't browse your site the way people do — they query structured data, ingest feeds, and increasingly call APIs to evaluate and transact. To be discoverable you have to make your catalog machine-readable (structured data), reachable (feeds and APIs pushed to the surfaces agents use), and trustworthy (accurate, fresh, well-reviewed). Get those three layers right and your products enter the agent's consideration set; skip any of them and you're simply invisible on the fastest-growing discovery channel in retail.

This is now a revenue question, not an IT-backlog one. Adobe's reporting showed AI-driven traffic to retail sites grew roughly sevenfold over the 2025 holiday season, and by early 2026 AI-referred shoppers were converting better than traditional traffic — a reversal from a year earlier, when the same cohort converted worse. The gap between merchants whose catalogs are agent-ready and those who aren't is widening fast.

How AI shopping agents actually read your catalog

A traditional search crawler tries to infer meaning from your page copy. An AI agent does the opposite: it wants explicit, structured facts and refuses to guess. When a shopper asks an assistant for "waterproof hiking boots under $200 that ship by Friday," the agent decomposes that into constraints — category, attribute, price, delivery window — and then evaluates candidate products against structured fields. Three implications follow:

• It queries attributes, not paragraphs. Marketing prose written for humans on the page contributes little. The agent reads product type, identifiers, price, availability, shipping, and returns as discrete fields.
• Incomplete data gets skipped, not tolerated. A human overlooks a missing spec; an agent treats a missing required field (a GTIN, a per-variant stock status) as grounds to exclude the product entirely.
• It decides in real time. Agents commit to a purchase in the moment, so a price or stock level that's even a few minutes stale produces a failed transaction — and a reliability penalty that hurts your future ranking.

The practical takeaway: your product data quality is now part of your distribution strategy.

The nine things to get right

1. Add Schema.org structured data (JSON-LD) to every product page

This is the foundation layer. Mark up Product and Offer with name, SKU, brand, GTIN, price, currency, availability, shipping, return policy, and aggregate rating. JSON-LD lets an agent extract the essentials without rendering your page. Schema-tagged product pages are also cited materially more often in AI-generated shopping results.

2. Complete your identifiers and attributes — especially GTINs

Missing GTINs (or manufacturer part numbers) are one of the most common reasons product lines get disqualified, because the agent can't reliably match the product. Populate unique product IDs, GTIN/UPC, brand, and category consistently. Aim for near-complete fill on your core fields; practitioners report that products with thin attribute coverage are routinely skipped, while high-fill catalogs get surfaced.

3. Get variants right

"Blue running shoes, sizes 7–13" is not one product to an agent — each variant needs its own accurate availability. Showing "in stock" when size 10 is sold out creates a failed checkout and damages your standing with the agent.

4. Write descriptions for intent, not for someone already on the page

Most product copy assumes the shopper has seen the image and filtered by category. An agent reads the description in isolation and needs it to answer the questions a shopper asks in conversation: who is this for, what's it used for, what's it compatible with, where would I use it. Add the same rigour to alt text ("men's linen shirt in pale blue, open-collar, outdoor setting" — not "IMG_4521.jpg") and to category descriptions, which set the interpretive frame for everything beneath them.

5. Keep feeds real-time accurate and internally consistent

Price and availability should reflect reality within minutes, not hours — the ChatGPT feed spec, for instance, accepts refreshes as often as every 15 minutes. Three failure modes to eliminate: price mismatch between your site and your feed (agents may reject or deprioritise you), stale stock, and missing geographic availability (recommending something that can't ship to the buyer is a failed experience).

6. Syndicate feeds to the surfaces agents actually use

Discoverability is per-channel. The main destinations in 2026:

• Google Merchant Center — feeds Google's AI Overviews / AI Mode and its emerging cross-surface cart.
• OpenAI / ChatGPT — sign up at chatgpt.com/merchants and provide a structured feed (CSV, TSV, XML, or JSON) pushed over HTTPS to an allow-listed endpoint. Merchants selling through Shopify or Etsy are already integrated with no extra setup.
• Perplexity and Microsoft Copilot shopping surfaces.
• If you're on Shopify, Agentic Storefronts can syndicate one catalog to several of these at once.

7. Expose programmatic access — APIs and an MCP server

Discovery alone isn't enough once agents start transacting. To participate in the full lifecycle, your catalog, cart, checkout, inventory, shipping, returns/refunds, and order management should all be reachable via API — not locked behind browser-only sessions. The cleanest way to make your catalog agent-native is to expose a Model Context Protocol (MCP) server with tools like searchProducts, getProduct, getInventory, createCart, and getShippingOptions. Any compliant agent (Claude, OpenAI's agent, LangChain-style frameworks) can then call your source of truth directly instead of scraping rendered pages.

8. Build trust and authority signals

Agents weight reliability heavily. Invest in review volume and recency, publish clear return, privacy, and terms policy URLs (some feed specs require them), keep pricing competitive across channels, and expose a clear seller identity. Brand authority in the wider web corpus also influences whether an LLM recommends you at all.

9. Support agent payment authorisation

For agents that complete purchases, you'll eventually need to accept scoped, single-use payment credentials — e.g. Stripe's Shared Payment Token or the Delegated Payment Spec — while remaining the merchant of record on your existing processor. Google's agent-payment model adds pre-authorisation scoped by amount, merchant, time window, and product class. This is a 2026 awareness item and a 2026–27 build item for most teams.

The protocol landscape in 2026

The standards stack is still settling, but four names matter:

• MCP (Model Context Protocol) — Anthropic's open standard for letting agents discover and call tools on external systems. It's the most settled of the four (shipped late 2024, with support across major agents and frameworks) and is the natural way to make a catalog directly queryable.
• ACP (Agentic Commerce Protocol) — co-developed by OpenAI and Stripe, open-sourced under Apache 2.0, and the protocol behind ChatGPT's shopping. It bundles a Product Feed Spec, an Agentic Checkout Spec, and a Delegated Payment Spec.
• AP2 (Agent Payments Protocol) — Google's payments-and-authorisation layer, using verifiable credentials so a user can pre-authorise an agent within defined limits. Less mature; the spec and reference implementations exist but issuer/processor support is still building.
• UCP / "Universal Cart" — a newer, Google-backed effort to standardise catalog and checkout access across platforms and be protocol-agnostic (REST, MCP, A2A). Emerging — worth tracking rather than building against yet.

One important nuance: OpenAI has been shifting emphasis away from a standalone in-chat checkout toward product discovery plus merchant-owned checkout — shoppers evaluate products inside ChatGPT, then complete the purchase on your own site or app, with no fee on purchases that start in ChatGPT. Product results there are organic and unsponsored, ranked on relevance rather than paid placement. So the highest-leverage move for most merchants is still the feed and data work, not rushing to build a bespoke in-chat checkout.

How to know if it's working

Don't assume — verify:

• Ask ChatGPT, Perplexity, and Gemini to find products in your category with specific attributes, and note whether yours appear and how they're described.
• Check that the price, availability, and shipping the assistant shows are actually correct.
• Test edge cases: specific sizes, colours, configurations, and ship-to regions.
• Use Google Merchant Center's feed diagnostics to catch disapprovals and missing required fields.
• Watch for a new channel in your analytics — chat-originated / AI-referred orders — and track its conversion separately.

How Core dna makes this easier

Most of the pain above comes from one root cause: catalogs and inventory scattered across systems that were built to render pages for humans, not to answer machines. Core dna is API-first and composable by design, which puts you in the ready camp by default rather than retrofitting agent-readiness onto a page-driven store.

• A single structured source of truth. Your products, variants, categories, stock, orders, and fulfilment live in one canonical, structured model — the "clean schema, clean data" foundation every agent surface depends on. There's no reconciliation between a storefront, a PIM, and a plugin-generated feed drifting out of sync.
• Full-lifecycle REST/JSON APIs. Catalog, cart, checkout, inventory, shipping, orders, and fulfilment are all programmatically accessible — exactly the end-to-end reachability agents need to move from recommending your product to transacting against it.
• A native MCP server. Core dna already exposes your catalog, inventory, and order data as MCP tools an agent can call directly. This is the single hardest item on the checklist — making your source of truth agent-native — and it ships as part of the platform rather than being a project you scope from scratch.
• Compliant feeds from the canonical catalog. Because the product data is already structured and centralised, generating and refreshing the feeds the AI surfaces expect (OpenAI, Google Merchant Center, and others) draws from one accurate, real-time source — so price and stock stay consistent everywhere.
• Multi-property orchestration. If you run several brands, regions, or storefronts, you maintain one catalog and syndicate consistent data to every property. That directly solves the failure mode other platforms warn about — hundreds of fulfilment points and one stale price silently breaking the agent experience.

The strategic point: in an agentic world, the advantage sits with the operator who runs the whole digital estate from one back end, not the one who bolts a store onto a single channel. Shopify sells you a store; Core dna runs your estate — and an estate that's structured, API-first, and MCP-native is exactly what AI shopping agents are built to read and buy from.

(ACP checkout endpoints and agent-payment authorisation, e.g. AP2 / Delegated Payment, sit naturally on top of this composable architecture as integration points — you bring your own PSP and expose the endpoints against your existing order and checkout APIs.)

Where to start

A pragmatic order of operations:

1. Fix the data. Audit fill rates on GTINs, variants, prices, availability, images, and policies. Treat gaps as disqualifications, because agents do.
2. Add Schema.org JSON-LD to product and category pages.
3. Rewrite descriptions and alt text for intent — who, what for, compatibility, context.
4. Stand up real-time feeds to Google Merchant Center and OpenAI (chatgpt.com/merchants), refreshed frequently, and connect any others you sell through.
5. Expose programmatic access — your APIs and an MCP server — then layer in agent-payment support as those protocols mature.

Then test with the assistants directly, and iterate on whatever they get wrong.

Sources & further reading

• OpenAI — Buy it in ChatGPT and Agentic Commerce overview: https://openai.com/index/buy-it-in-chatgpt/
• OpenAI — Merchant onboarding: https://chatgpt.com/merchants/
• OpenAI — Agentic Commerce key concepts (developer docs): https://developers.openai.com/commerce/guides/key-concepts
• Agentic Commerce Protocol — Product Feed Specification: https://agentic-commerce-protocol.com/docs/commerce/specs/feed
• Model Context Protocol: https://modelcontextprotocol.io
• Schema.org — Product / Offer vocabulary: https://schema.org/Product
• AI-commerce traffic and conversion trends as reported by Adobe (Adobe Analytics / Digital Insights, 2025 holiday season and early 2026).