When the AI Picks the Product,

The New Shelf

A shopper asks ChatGPT for a running jacket under $150 that packs into its own pocket. The model names three products. It does not name yours — and nothing in your analytics will ever tell you it happened. That moment is the new shelf: the place a product either appears or doesn't when someone shops inside an AI answer. No impression served, no auction lost, no error logged. Just absence.

The reflex is to treat this as a marketing problem — a visibility campaign, a PR angle, a prompt-engineering trick. It's a data problem. Every major AI shopping surface selects products by reasoning over structured product data, and the merchant's only durable lever is the quality of the signal in the catalog. The surfaces didn't make feeds obsolete. They made feed quality the whole contest.

That distinction — listed versus recommended — is the conceptual anchor for everything in this guide. Enrollment gets a catalog onto the shelf. It does not get a product into the answer. A merchant can be fully connected to every surface below, confirm ingestion, and still never appear in a recommendation, because the model had a competitor with denser data to reason over. The rest of this guide is about winning the second contest.

What Every Surface Shares

Four claims hold across ChatGPT, Perplexity, Google AI Mode, and Microsoft Copilot, and they carry the weight of this guide. First: the merchant-pushed feed is canonical. Every surface treats submitted product data as the source of truth and crawls the website only as a fallback. "The AI reads your site" is the fallback path, not the main one — and the fallback inherits every gap in your on-page markup.

Second: listed is not recommended. Ingestion is table stakes; ranking inside an answer is decided by attribute completeness, identity integrity, and accuracy. Third: there is no enterprise gate. Entry to every surface is free, which means the contest is open to every competitor with a cleaner catalog — including ones far smaller than you. Fourth: the checkout layer is volatile and the feed work is stable. Agentic checkout programs launch, scale back, and relaunch; the product data those programs read stays the same investment, and it compounds across all four surfaces at once.

Key Insight: One engineered catalog serves four surfaces. The feed you already build for Merchant Center is most of the way to Perplexity and Google AI Mode; the marginal work is per-surface spec compliance, not a new pipeline per surface.

The four surfaces converge on the idea and diverge on every mechanic — required fields, identity keys, ingestion paths, checkout status. The next four sections take them one at a time.

ChatGPT

OpenAI's merchant program ingests a dedicated product feed against a stable schema of fifteen fields. The spec is narrower than Google's and weighs things differently: GTINs are optional, while three signals carry the trust load — GTIN integrity where present, availability accuracy, and structured review data. A listing with clean identity, current stock status, and real review markup is the profile the surface treats as credible.

Instant Checkout reset expectations in March 2026, scaling back from transaction toward discovery. The lesson merchants should take is not that agentic checkout failed — it's that the checkout layer is the volatile part of this stack. What survived the pivot untouched is the discovery requirement: real-time price and availability accuracy still decide whether a product is in the answer at all. A stale availability field was once a disapproval. Inside a chat, it's a recommendation the model declines to make.

Ads ≠ Organic: ChatGPT Ads run on separate Ads Manager feeds, and during the beta those feeds are ads-only — they do not place products in organic answers. Buying ads does not buy recommendation. The organic contest is still decided by the merchant program feed and its data quality.

The diagnostic worth running this week: ask ChatGPT to shop your own category, in the language a real customer would use, and see whether you exist. Merchants who run this test for the first time tend to discover the gap between connected and visible personally — often on a product they know outsells everything the model actually named.

Perplexity

Perplexity's Merchant Program is the lowest-friction entry in AI shopping: it ingests the same Google Shopping-format feed you already build for Merchant Center, the base tier is free, and enrollment is mostly unclaimed territory. The GTIN is the identity key — it's how Perplexity resolves a product against its catalog graph, and thin GTIN coverage is the most common reason an enrolled catalog underperforms there.

The counterintuitive mechanic: a competitor with a smaller catalog can outrank you, consistently, because attribute completeness and identity coverage beat catalog size. Perplexity's answer engine rewards the product it can describe and verify most fully, not the merchant with the most SKUs. For a mid-market catalog competing against larger assortments, that's the rare contest where the structural advantage runs in your favor — if the data density is there.

Key Insight: One feed, two surfaces: the Google-format feed is the build. Perplexity is a second consumer of work you've already done — provided that work was done to spec, with GTINs resolved rather than padded.

Google AI Mode and Gemini

Google's AI surfaces read the Merchant Center feed you already run — and if free listings are enabled, which they are by default for enrolled merchants, you're probably already on this shelf. The contest here is not enrollment and it is not bidding. It's attribute completeness, because AI Mode grounds its shopping answers in the Shopping Graph, and the graph knows your products exactly as well as your feed describes them.

A feed tuned for Shopping ads underperforms in AI Mode, because the two consumers reward different things. The ads auction leans on titles, custom labels, and bid-adjacent structure. Conversational grounding leans on descriptive completeness — the material, use-case, and compatibility attributes that let a model answer a question phrased the way a person actually asks it. The same catalog can be strong signal for one consumer and thin signal for the other.

Two infrastructure facts frame this surface. The Content API sunsets August 18, 2026 — a pipeline still on the legacy API is days from breakage, and everything AI-side sits downstream of that migration. And the Universal Commerce Protocol is Google's push toward agentic transaction: AI agents completing purchases without a human in the loop. UCP is billed as eliminating the middle layer. It does the opposite — an agent transacting autonomously requires immaculate structured data, because there's no human in the flow to catch the error a sloppy catalog introduces. This is GoDataFeed's home surface: the Merchant Center feed is the payload the entire Google AI stack reads, and engineering it is the same rules-engine work the platform has always done.

Microsoft Copilot

Copilot is the fourth column and the least contested one. Microsoft ingests product data through Microsoft Merchant Center via a UCP feed, keyed on a unique Merchant Item ID rather than the GTIN-first identity logic of the other surfaces — a spec difference that catches merchants who assume Google's rules travel. For catalogs already syndicating to Microsoft for shopping campaigns, the feed infrastructure is in place; the work is verifying the UCP field set and identity mapping against Microsoft's spec rather than standing up anything new.

The strategic read: Copilot inherits Microsoft's distribution — Windows, Edge, Office — which puts a shopping answer surface in front of buyers who never open a chat app deliberately. Low contest, existing pipe, marginal cost. It's the surface most merchants will get around to last and the one where early spec compliance is cheapest.

Refresh, Drop Rules, and the Accuracy Contest

All four surfaces punish the same thing: a feed that lies about price or stock. The enforcement differs — disapproval here, quiet de-ranking there — but the principle is uniform, and it's stricter than the ads-era version. An ad served against a stale price costs a click. A recommendation made against a stale price costs the surface's trust in your catalog, and the surfaces are engineered to protect their own credibility first. One bad answer traced to your data and the model has every incentive to stop naming you.

This is what makes refresh cadence a competitive variable rather than plumbing. Price changes, stock-outs, and promotion windows have to propagate to every surface faster than a shopper can ask about them. A daily sync was adequate for a comparison shopping engine. It is not adequate for a surface that answers in real time and remembers being wrong. The drop rules turn a single systematic error — one mispriced sale, one unflagged stock-out pattern — into an invisibility event across the exact surfaces where you can't see yourself missing.

The Stable Investment: Checkout programs will keep launching and scaling back. Specs will revise. What doesn't change: every surface reads structured product data as canonical and ranks on completeness and accuracy. The catalog work is the stable investment underneath a volatile layer — and it compounds across all four surfaces at once.

The Pre-Flight Checklist

The checklist below compresses the guide into three working tools: the four surfaces at a glance, the cross-surface attribute audit, and the drop-trigger triage — enough to pre-flight a catalog against every AI surface before submitting to any of them.

The four surfaces at a glance

• ChatGPT — Feed it reads: OpenAI product feed (stable schema, 15 fields). Identity key: GTIN optional — trust rides on availability + review data. How you get in: OpenAI merchant program enrollment.
• Perplexity — Feed it reads: Your Google Shopping-format feed. Identity key: GTIN — the identity key. How you get in: Perplexity Merchant Program (free tier).
• Google AI Mode — Feed it reads: Your Merchant Center feed. Identity key: GTIN required where one exists. How you get in: Free listings — on by default when enrolled in GMC.
• Microsoft Copilot — Feed it reads: UCP feed via Microsoft Merchant Center. Identity key: Unique Merchant Item ID. How you get in: Microsoft Merchant Center enrollment.

Pre-flight attribute audit — before you submit to any AI surface

• title + description (All four) — Semantic matching — the text the model reasons over when it picks a product for an answer. Self-check: Written in complete, specific language: brand, product type, material, use case — not storefront shorthand
• gtin (Varies) — Identity and cross-surface matching — optional in ChatGPT's spec, the key in Perplexity, required-where-exists in Google. Self-check: Checked against each surface's spec, not assumed; exemptions flagged, never faked
• price (All four) — Trust — a feed price that disagrees with the landing page reads as a lie. Self-check: Matches the landing page at every refresh, sale pricing included
• availability (All four) — Whether the product can be recommended at all — stale stock status is a lost answer, not a cosmetic error. Self-check: Refresh cadence tight enough that stock-outs propagate before a shopper asks
• image_link (All four) — Rich-card eligibility — text mentions convert worse than cards. Self-check: Every SKU carries a valid, current image; variants carry their own
• structured review data (Rec.) — Trust signal in ChatGPT's ranking; social proof the model can cite. Self-check: Review schema present and valid on product pages; ratings flow into the feed where the spec accepts them
• product schema (on-page) (Rec.) — The crawl-side corroboration for every surface's fallback path. Self-check: Schema.org Product markup matches the feed — same price, same availability, same GTIN
• category / taxonomy (All four) — Which questions the product is a candidate answer for. Self-check: Mapped to the most specific node each surface's taxonomy allows
• attribute completeness (All four) — The recommendation contest — listed is free, picked is won on data density. Self-check: Every optional field the spec accepts is populated; sparse SKUs identified and enriched

Drop triggers — what turns one error into invisibility

• Price mismatch vs. landing page — All four surfaces punish the same lie. Reconcile feed against page before every submission window; audit sale-price fields first.
• Stale availability — Tighten refresh cadence. An out-of-stock item recommended in an answer damages surface trust in the whole catalog.
• Missing identity (GTIN / item ID) — Check the spec per surface — do not assume Google's rules travel. Perplexity keys on GTIN; Microsoft keys on Merchant Item ID.
• Sparse attributes on eligible SKUs — You are listed but never recommended. Enrich descriptions and optional fields — completeness beats catalog size.
• Feed/schema disagreement — The crawl fallback contradicts your push. Align on-page Product markup with the feed so both paths tell one story.

A checklist finds the gaps. Closing them — descriptions enriched to answer-grade density, GTINs resolved per surface, price and availability syncing at answer speed, on-page schema agreeing with the feed — is catalog-scale data engineering, and the Merchant Center feed at the center of it is the payload GoDataFeed has always built. The fastest way to see where your catalog stands is to look at what you're actually sending.

1. OpenAI product feed specification and merchant program documentation
2. Perplexity Merchant Program documentation
3. Google Merchant Center product data specification; Content API migration timeline (Merchant API, August 2026)
4. Universal Commerce Protocol announcements (Google, 2026)
5. Microsoft Merchant Center documentation
6. GoDataFeed AI Shelf research dossier (internal)