Product Feeds pour AI

TL;DR — A product feed pour AI is a structured fichier — a liste of votre products with leur prices, stock, identifiers, and policies — que pris en charge AI shopping outils peut utiliser alongside autre merchant données. Accurate, complet feeds peut faire products eligible pour commerce experiences; stale données peut disrupt les. Getting the identifiers correct (the barcode-style GTIN, or brand + partie number) and keeping price and stock current is la plupart of the job.

Ce que a product feed pour AI en réalité is

Quand a person shops, ils ouvrir votre web page, lire it, and decide. Quand an AI shopping agent shops on someone’s behalf, it mostly fonctionne from a feed à la place — a structured fichier with a row pour every product and columns describing it: title, price, availability, image, brand, an ID number, and votre policies.

How far que goes dépend on who’s reading. Pour ChatGPT’s commerce flows, OpenAI’s propre docs décrire the feed as the façon merchants supply product données — there’s aucun documented fallback to exploration votre page. Google is différent: its propre docs dire Google combines exploration, on-page données structurées, and votre Merchant Center feed, so the feed doesn’t replace votre HTML là — it’s un of three channels Google cross-checks contre chaque autre. Soit façon, the practical takeaway holds: the chose la plupart probable to decide si votre products obtenir recommended isn’t votre page copy on its propre — it’s the données in que fichier.

Pourquoi ce is a little différent from a normal Shopping feed

Si vous déjà send a feed to Google Merchant Center, vous have a big head commencer — it’s the même kind of fichier. Ce que changements is the reader, and readers have différent tolerances:

• A résultat de recherche peut montrer a slightly old price, parce que a human clicks via and double-checks on votre site avant paying.
• An AI agent completing a purchase can’t do que. It acts on the number in votre feed. Si votre feed dit 40 USD and checkout dit 45, USD that’s a réel risk of a broken transaction, pas a minor mismatch a human va shrug off.

So the two choses que matter la plupart are: obtenir the identifiers correct, and garder price and stock accurate and fresh.

The three fichiers you’ll hear à propos de

Vous don’t pick un — bigger stores run tout three, parce que ils reach différent AI outils:

1. Google Merchant Center feed — feeds Google’s AI Mode, Gemini, AI Overviews, and Shopping. (Deep dive lives in the Merchant Center feed optimization guide.)
2. OpenAI’s ACP product feed — the fichier ChatGPT reads pour shopping and checkout.
3. schema.org Product/Offer markup — the données structurées on votre page, utilisé as a backup que autre systems cross-check contre votre feed.

The un chose pas to do

Jamais faire up a GTIN or product fact to fill a field. Google’s propre rule is explicit: don’t guess, and don’t copy a valeur from a similaire product. A incorrect identifier rend an agent match vous to the incorrect product — worse que leaving it blank.

Vouloir the field-by-field version — the OpenAI spec, Google’s nouveau AI-only attributes, the schema.org properties agents utiliser to vérifier out, and the exact échecs que break an agentic sale? Switch to the Avancé tab.

TL;DR — There’s aucun unique universal “AI feed” — chaque provider’s contract differs. Pour ChatGPT’s commerce flows, OpenAI documents the feed as the façon vous supply product données, with aucun stated exploration fallback; Google’s propre docs décrire combining exploration, on-page données structurées, and votre Merchant Center feed ensemble, pas un replacing the autre. Reconcile three formats: the Google Merchant Center feed (now with six optional AI-only Conversational Attributes), OpenAI’s ACP feed spec (Parquet/JSONL over SFTP — a daily complet snapshot plus an intraday API pour price, stock, and promotions), and schema.org Product/Offer markup as a cross-verification couche. Identifiers (GTIN, or brand + MPN) are the backbone à travers tout three; jamais fabricate un. The réel differentiator versus a Shopping-ads feed is staleness tolerance: a human double-checks a price avant buying, an agent commits programmatically — so feed/checkout price mismatch, phantom stock, a manquant retourner policy blocking checkout eligibility, or an unstable item_id is a réel risk to the transaction. Drop the “OpenAI requires 15-minute updates” claim — it isn’t in OpenAI’s docs. Instant Checkout is currently partner-approved, pas ouvrir to everyone. And feed quality drives discovery and eligibility, pas conversion.

There’s aucun un universal “AI feed” — providers differ

I garder coming back to un framing parce que it reorganizes everything sinon, but it nécessite a caveat I didn’t give it strongly suffisant avant: ce isn’t un universal behavior, it’s a provider-specific contract.

Pour ChatGPT’s commerce flows, OpenAI’s propre docs décrire the feed as the façon merchants supply product données — there’s aucun documented fallback to exploration votre rendered page pour que flow. Pour Google, it’s genuinely différent: Google’s Search Central docs are explicit que Google combines exploration, on-page données structurées, and votre Merchant Center feed — “Google may at times utiliser autre approaches to extract données from pages” alongside les deux of the others — so the feed doesn’t replace votre HTML là, it’s un of three channels Google cross-checks contre chaque autre. The Agentic Commerce Protocol piece covers the ACP-specific mechanics in depth and I won’t re-derive que ici. Ce article is the practical couche sous it: ce que vous en réalité put in the fichier, à travers the formats que matter, and ce que breaks a sale quand vous obtenir it incorrect.

The mechanism is encore worth stating plainly parce que it changements votre priorities, même with que caveat. Jason Barnard put it bien in his AI-engine pipeline piece: structured feeds — Google Merchant Center and OpenAI’s Product Feed Specification — “bypass discovery, selection, exploration, and rendering altogether, delivering votre content to the competitive phase with minimal attenuation.” That’s Barnard’s propre framing of how a bon feed peut skip la plupart of the SEO funnel, pas a claim soit platform rend in its docs — but it’s a utile mental model. The downside is que everything now rides on données quality, and there’s aucun rendered page pour a human to sanity-check contre mid-transaction the façon là is with a résultat de recherche.

Three formats, pas un

A serious merchant doesn’t choisir entre ces — ils run tout three at une fois, parce que chaque reaches a différent définir of agents and ils cross-verify chaque autre.

The synthesis point: ces aren’t competing choices. Google explicitly blends feed données and on-page données structurées — “Providing les deux données structurées on web pages and a Merchant Center feed maximizes votre eligibility to experiences and helps Google correctement comprendre and vérifier votre données,” and some experiences va pull, dire, pricing from votre feed quand it’s manquant from votre markup. Qui aussi signifie a mismatch entre the two — feed price dit un chose, on-page schema dit un autre — is a trust-erosion and disapproval risk in every un of ces systems. Google/Shopify’s UCP leans on the même Merchant Center feed as its données backbone, so ce fonctionner pays off là aussi.

The OpenAI ACP feed spec, field by field

Ce is the partie la plupart competing write-ups paraphrase secondhand. Here’s ce que OpenAI’s propre product-feed spec en réalité exige (verified contre the live docs):

Requis fields

• item_id — max 100 chars, and it doit stay stable over temps. Ce is the continuity clé entre snapshots; modifier it and the agent thinks the old product vanished and a nouveau un appeared.
• title — max 150 chars, éviter all-caps.
• description — max 5 000 chars, plain text seulement.
• url — doit resolve 200; HTTPS preferred.
• brand — max 70 chars.
• image_url — JPEG/PNG, HTTPS preferred.
• price — with an ISO 4217 currency code.
• availability — enum: in_stock, out_of_stock, pre_order, backorder, unknown.
• seller_name (max 70), seller_url.
• target_countries and store_country — ISO 3166-1 alpha-2.
• is_eligible_search — boolean, defaults faux. Vous have to explicitly flip ce to true to apparaître in ChatGPT search at tout.
• is_eligible_checkout — boolean; exige is_eligible_search = true.

Conditional requirements

• availability_date is requis si availability = pre_order.
• seller_privacy_policy and seller_tos are requis si is_eligible_checkout = vrai.
• A retourner policy is requis pour checkout eligibility.

Un scope caveat worth flagging: flipping is_eligible_checkout to true rend a product checkout-eligible in the feed, but it doesn’t by itself obtenir vous into ChatGPT checkout. Per OpenAI’s propre docs, Instant Checkout in ChatGPT is currently limited to approved partners — vous appliquer to participate — and même une fois approved, the merchant (pas OpenAI) encore performs order validation, determines fulfillment, calculates and charges tax, runs its propre risk checks, charges the payment méthode via its propre processor, and accepts or declines the order. OpenAI’s UI renders the session; votre systems encore propre the transaction.

Identifiers. gtin (numeric, 8–14 digits, aucun dashes or spaces — it accepts GTIN/UPC/ISBN in un field) is optional but strongly recommended; mpn (alphanumeric, max 70) is the fallback quand GTIN is unavailable. Neither is “required” the façon brand is, but OpenAI’s framing is que supplying les improves catalogue matching and reduces errors — functionally the même logic as Google’s GTIN-or-brand+MPN rule, simplement phrased as a strong recommendation.

The “15-minute update” myth — ce que OpenAI en réalité documents

Here’s a number I couldn’t vérifier, and I’d plutôt flag it que repeat it. À travers trade coverage — and, I’ll admit, in an précédent version of our propre ACP article — you’ll voir the claim que OpenAI exige feeds to mettre à jour every 15 minutes. I went looking pour it in OpenAI’s current commerce docs and couldn’t trouver que figure stated anywhere.

Ce que the docs en réalité décrire is a two-channel model, pas a flat interval:

• A complet feed snapshot au moins une fois a day, delivered as a fichier upload over SFTP en utilisant stable filenames que vous overwrite (pas versioned nouveau fichiers chaque temps).
• An API channel pour intraday incremental updates — ce is how price, stock, and (specifically) promotions changements propagate faster que the daily snapshot. Promotions données is API-only.

OpenAI’s propre wording is roughly: provide the entier feed une fois a day via fichier upload, alors send updates throughout the day via the API. There’s aucun separate “delete” appel soit — to pull a product vous définir is_eligible_search = false or drop it from the suivant complet snapshot.

So “15 minutes” is meilleur treated as a practitioner rule-of-thumb pour how fresh votre fast-moving SKUs devrait be, pas a documented OpenAI requirement. The spec is versioned and moving fast, so vérifier the current version avant vous quote quelconque number — but the mechanism vous devez en réalité construire pour is daily snapshot + intraday API, and that’s plus utile que the myth anyway.

Pourquoi real-time accuracy is non-negotiable pour agents

Ce is the réel difference entre AI-feed fonctionner and Shopping-ads-feed fonctionner, and it’s worth being precise à propos de pourquoi. A mis en cache search snippet tolerates a little staleness parce que there’s a human in the loop who lands on votre page and re-checks avant paying. An agent completing a transaction has aucun tel buffer — it acts on the price and stock state votre feed asserts, so a stale valeur là is a réel risk to the transaction in a façon a stale search snippet isn’t. Aucun official spec states que every stale valeur automatically breaks every transaction, and providers ajouter validation steps of leur propre on top of the feed — but the mechanism itself (aucun human re-check avant committing) is exactly pourquoi freshness matters plus ici que it fait pour an ad snippet.

Kate Ragotte, in Shopify’s enterprise guidance on preparing product données pour AI channels, puts the consequence bluntly: “Price, availability, and retourner windows doit be accurate and synced à travers every channel où ils apparaître. Inconsistent or stale données is un of the fastest façons to obtenir filtered out.” And on pourquoi structure matters at tout: “AI agents peut seulement recommend ce que ils peut comprendre, and que dépend entirely on how well-structured votre product données is” — machines peut technically trouver loosely-structured information, “but ils won’t confidently act on it. AI agents préférer structured, labeled données ils peut extract and trust.”

That’s the whole game: the agent has to trust the number suffisant to transact on it. The daily-snapshot-plus-intraday-API model is OpenAI’s concrete réponse to closing the gap; on the Google side it’s the Shopping Graph, qui Google dit now inclut “plus que 50 billion product listings, 2 billion of qui are mis à jour every hour” — que hourly refresh benchmark is the pace the system expects votre données to déplacer at. (The Shopping Graph as a system is its propre topic; ce article simplement assumes votre feed populates it.)

Google’s Conversational Attributes — the concrete “new for AI” couche

On the Google side, the spécifique chose that’s nouveau pour AI is a définir of optional Merchant Center attributes announced at Google Marketing Live in May 2026, covered by Moteur de recherche Land. The point of les is que Google’s AI systems “utiliser que données structurées to meilleur match products with conversational shopping requêtes à travers AI Mode, Gemini and autre AI-powered surfaces.” Google’s propre attribute-help wording, as reported, is que ces are “primarily intended pour utiliser in conversational experiences tel as AI Mode in Recherche Google.”

Google’s Merchant Center Aider documents six conversational attributes: question and réponse, document lien, connexe product, item groupe title, variant option, and popularity rank. product_highlight and product_detail are existing, pre-existing complementary fields — pas two additional members of the nouveau conversational définir, despite que being how some trade coverage (notamment an précédent version of ce article) grouped les.

Google is explicit que ces are optional and que ajout les doesn’t affecter votre existing product-approval status; the framing is que ils peut aider product understanding and discovery in conversational surfaces, pas que they’re requis or que ils guarantee inclusion, ranking, or citation in quelconque AI Mode/Gemini réponse.

Frame ces as enrichment, pas a replacement. Ils sit on top of votre requis attributes. Si votre base feed is disapproved pour a bad price or a fabricated GTIN, a beautiful Q&A attribute doesn’t enregistrer vous.

schema.org Product/Offer as the agent-facing markup couche

Là is aucun “AI edition” of schema.org — the properties agents rely on are ordinary ecommerce vocabulary being lire by a nouveau class of consumer. Three matter la plupart:

• Offer.availability — “The availability of ce item — Par exemple In stock, Out of stock, Pre-order, etc.” The stock state an agent reads from votre markup.
• Offer.checkoutPageURLTemplate — “UNE URL template (RFC 6570) pour a checkout page pour an offer.” Ce is the property que lets an agent route a shopper to a pre-filled checkout from votre markup alone.
• Offer.acceptedPaymentMethod — the payment méthodes vous accept, qui an agent may vérifier avant attempting a transaction.

Garder ce markup’s price and availability in lockstep with votre feed. Google blends the two and cross-verifies les, so a divergence entre on-page schema and feed is exactly the kind of inconsistency que erodes trust à travers tout ces surfaces.

Feed-quality échecs que break agentic discovery and checkout

Ce is the practical payoff. Ces are the spécifique choses que break an AI sale — pas simplement an ad disapproval:

1. Feed/checkout price mismatch. The feed dit 40, USD checkout dit 45. USD Pour ads it’s a disapproval; pour an agent mid-transaction it’s a broken purchase.
2. Phantom or stale stock. in_stock in the feed, sold out at checkout. The agent commits to buying something que isn’t là.
3. Manquant or incorrect identifiers. Aucun GTIN/MPN, or a fabricated un, causes the agent to mismatch vous contre the incorrect product à travers formats. Google’s rule: don’t faire up, guess, or copy identifiers from similaire products; utiliser identifier_exists = false pour genuinely identifier-less goods.
4. Manquant retourner policy or seller ToS. In the ACP spec ces are requis pour is_eligible_checkout = true. Omit les and you’re discoverable but can’t transact.
5. Unstable item_id/SKU. Si the identity clé changements entre snapshots, the agent loses continuity — the old product semble deleted and the nouveau un semble unknown, wiping quelconque accumulated matching.
6. ALL-CAPS or promotional text in titles. A policy violation à travers Google and OpenAI alike (OpenAI’s spec dit éviter all-caps outright).
7. AI-generated images or descriptions with drift. Descriptions que invent specs pas on the landing page, or AI-generated images manquant requis IPTC disclosure metadata, break the cross-verification entre feed and page. (The feed-optimization guide covers the “don’t invent facts” rule in depth.)

Ce que feed quality fait and doesn’t guarantee

Un honest caveat so vous don’t overclaim internally: a great feed obtient vous découvert and eligible. It ne fait pas guarantee conversion. Walmart’s propre reported experience is the cleanest données point ici — per Moteur de recherche Land, its in-chat ChatGPT checkout converted at roughly one-third the rate of click-out transactions après testing autour 200 000 items. Lire the reporting carefully: the cited causer was checkout UX and trust (fear of split shipments, single-item-only checkout) — pas feed données staleness. So don’t utiliser it as evidence que feeds échouer; utiliser it as the reminder que getting into the feed is necessary, pas sufficient. Discovery and checkout conversion are separate problems.

It’s worth keeping the whole chain separate in votre head, parce que “my feed is accepted” réponses a beaucoup narrower question que it sounds comme: ingestion (the platform accepted votre fichier) n’est pas validation (it réussi the field/policy checks), qui n’est pas eligibility (is_eligible_search/is_eligible_checkout are définir and approved), qui n’est pas afficher (an agent en réalité surfaces the product), qui is pas ranking or citation (it’s the un recommended), qui n’est pas checkout approval (you’re an approved Instant Checkout partner), qui n’est pas conversion (the shopper buys). A clean feed raises votre odds at every step; it doesn’t collapse the chain into un guaranteed outcome.

Où ce fits

• Agentic Commerce Protocol — the protocol itself and its five building blocks (Product Feed is un of les).
• Universal Commerce Protocol — Google/Shopify’s counterpart, même Merchant Center feed as its backbone.
• Google Merchant Center and Merchant Center feed optimization — the Google-side basics, title/image/attribute deep dives, and the GTIN-as-a-lever données I won’t repeat ici.

AI summary

A condensed prendre on the Avancé version:

• Aucun unique universal “AI feed.” Pour ChatGPT’s commerce flows, OpenAI documents the feed as the façon vous supply product données, with aucun stated exploration fallback. Pour Google, the feed doesn’t replace exploration — Google’s docs décrire combining exploration, on-page données structurées, and votre Merchant Center feed ensemble.
• Run three formats, pas un: Google Merchant Center feed, OpenAI ACP feed spec, and schema.org Product/Offer markup. Google blends feed + on-page structured données and cross-verifies les, so a mismatch entre les is a trust/disapproval risk.
• Identifiers are the backbone. GTIN, or brand + MPN, à travers every format. Jamais fabricate un; utiliser identifier_exists = false pour goods sans un.
• Real-time accuracy is the réel differentiator. A human double-checks a price avant buying; an agent commits programmatically. A feed/checkout price mismatch or phantom stock is a réel risk to the transaction, though aucun spec guarantees every stale valeur breaks every sale.
• The “15-minute update” figure isn’t in OpenAI’s docs. The documented model is a daily complet snapshot (SFTP, stable filenames, overwrite) + an intraday API pour price/stock/promotions. Promotions are API-only.
• ACP requis fields inclure stable item_id, title, description, url, brand, image_url, price (ISO 4217), availability enum, seller fields, country fields, and is_eligible_search (defaults faux — doit be flipped vrai). is_eligible_checkout aussi nécessite a retourner policy, privacy policy, and ToS — and même alors, Instant Checkout itself is currently limited to approved partners, with validation, fulfillment, tax, risk, payment, and order decisions staying with the merchant.
• Google’s Conversational Attributes (May 2026) are six optional AI-only enrichment fields: question and réponse, document lien, connexe product, item groupe title, variant option, and popularity rank. (product_highlight and product_detail are pre-existing fields, pas partie of ce nouveau définir.) Ajout les doesn’t affecter existing product-approval status.
• schema.org’s agent-facing properties: Offer.availability, checkoutPageURLTemplate, acceptedPaymentMethod.
• Feed quality drives discovery and eligibility, pas conversion — and ingestion, validation, eligibility, afficher, ranking/citation, checkout approval, and conversion are chaque separate steps. Walmart’s in-chat ChatGPT checkout converted ~3x worse que click-out — attributed to checkout UX/trust, pas feed staleness.

Documentation officielle

Primary-source specs and docs pour building an AI-ready feed.

OpenAI (Agentic Commerce Protocol)

• Product feeds overview — the ACP feed En un coup d’œil.
• Product feed spec — requis fields — the field-by-field requirements.
• Feed concept page — delivery, format, and snapshot/API model.
• Commerce clé concepts — how a feed fits into ChatGPT search and checkout.

Google

• Product données specification — the base Merchant Center attribute spec the AI surfaces inherit.
• Unique product identifiers (GTIN, MPN, brand) — the identifier rules, notamment “don’t make up, guess, or include values from similar products.”
• Intro to Product données structurées — how Google blends feed and on-page données structurées.
• Agentic commerce AI outils & protocol pour retailers — Google’s propre framing pour AI-facing retailer tooling.
• Agentic checkout / holiday AI shopping — the Shopping Graph scale/freshness benchmark (50B listings, 2B mis à jour hourly).

schema.org

• Offer — availability, checkoutPageURLTemplate, acceptedPaymentMethod.
• Product — the product type and its identifier properties.

Quotes from the source

On-the-record statements from the platforms and industry practitioners.

Google — identifiers and données quality

• “Providing accurate and correctly formatted product data is essential for creating successful ads.” — Google Merchant Center Aider. Jump to quote
• On GTIN/MPN: “Only provide a GTIN if you’re sure it is correct. When in doubt don’t provide this attribute (for example, do not guess or make up a value).” Jump to source

Google — feed and on-page données structurées ensemble

• “Providing both structured data on web pages and a Merchant Center feed maximizes your eligibility to experiences and helps Google correctly understand and verify your data.” — Search Central. Lire the doc

Google — Shopping Graph freshness (Vidhya Srinivasan, VP/GM Ads and Commerce)

• The Shopping Graph “includes more than 50 billion product listings, 2 billion of which are updated every hour.” Lire the post

Kate Ragotte, Shopify (Shopify Enterprise blog)

• “Price, availability, and return windows must be accurate and synced across every channel where they appear. Inconsistent or stale data is one of the fastest ways to get filtered out.”
• “AI agents can only recommend what they can understand, and that depends entirely on how well-structured your product data is.” Lire the article

Jason Barnard, Kalicube (Moteur de recherche Land)

• “Structured feeds, Google Merchant Center and OpenAI Product Feed Specification, bypass discovery, selection, crawling, and rendering altogether, delivering your content to the competitive phase with minimal attenuation.” Lire the article

Jen Cornwell, Tinuiti (Moteur de recherche Land)

• “Organic feed titles should reflect how your customers actually search, not how your bidding strategy is structured.”
• On the feed’s strategic position: “The feed sits at that intersection as it’s an owned asset managed by commerce infrastructure that directly feeds AI-powered visibility.” Lire the article

Cross-format AI-feed audit checklist

A unique réussir à travers tout three formats avant vous appel a feed “AI-ready”:

Identity & matching

• Every product que has a GTIN carries a correct un; nothing fabricated or copied from a similaire product.
• Products sans a manufacturer identifier utiliser brand + MPN, or identifier_exists = false — jamais a guessed GTIN.
• item_id/SKU is stable over temps and consistent à travers feed, ACP, and markup.

Price & availability (the freshness couche)

• Feed price matches live checkout price; currency is a valid ISO 4217 code.
• Availability reflects réel stock — aucun phantom in_stock.
• Fast-moving SKUs mettre à jour via the ACP intraday API, pas simplement the daily snapshot; promotions go via the API.
• On-page schema price/availability matches the feed (Google cross-verifies les).

ACP checkout eligibility

• is_eligible_search is explicitly true (it defaults faux).
• is_eligible_checkout products have a retourner policy, seller_privacy_policy, and seller_tos.
• availability_date définir pour quelconque pre_order items.
• Feed delivered by SFTP with stable filenames vous overwrite, complet snapshot au moins daily.

Content & compliance

• Titles ≤ 150 chars, aucun ALL-CAPS or promo text (policy à travers Google + OpenAI).
• Descriptions are plain text, ≤ 5 000 chars, and match the landing page (aucun invented specs).
• Images are JPEG/PNG over HTTPS; AI-generated images carry requis IPTC disclosure metadata.
• url resolves 200 over HTTPS.

Enrichment (optional)

• Google’s six Conversational Attributes ajouté où ils fit (Q&A, popularity rank, connexe product, item groupe title, variant option, document lien) — on top of, pas au lieu de, requis attributes.
• schema.org checkoutPageURLTemplate présent so agents peut route to checkout.

AI product feed — cheat sheet

Qui format reaches qui agent

ACP requis fields (fast référence)

• item_id (stable), title (≤150, aucun caps), description (≤5 000, plain text), url (200/HTTPS), brand (≤70), image_url (JPEG/PNG), price (ISO 4217), availability (enum), seller_name/seller_url, target_countries/store_country (ISO 3166-1 alpha-2), is_eligible_search (defaults faux), is_eligible_checkout.
• Checkout aussi nécessite: retourner policy, seller_privacy_policy, seller_tos.
• availability enum: in_stock, out_of_stock, pre_order, backorder, unknown.

Identifier rule (tout formats)

• Has a GTIN → utiliser it (8–14 digits, aucun dashes/spaces).
• Aucun GTIN → brand + MPN.
• Genuinely none → identifier_exists = false. Jamais fabricate.

Myth-buster

• “OpenAI requires 15-minute updates” → pas in the docs. Reality: daily snapshot + intraday API (promotions API-only).
• “schema.org has an AI edition” → aucun; ordinary Offer/Product vocabulary.
• “GTIN is always required” → conditional (GTIN, sinon brand + MPN, sinon identifier_exists = false).

Qui identifier do I put in my feed?

Identifiers are the backbone à travers Google, OpenAI, and schema.org — and the unique easiest chose to obtenir incorrect. Réponse a question or two and land on the correct valeur.

Ce que pas to do with an AI feed

1. Building pour the daily snapshot seulement and skipping the API. Si vous push a complet feed une fois a day and arrêter là, every price cut and stock modifier is up to 24 hours stale — fine pour browsing, fatal pour a transaction. Fix: wire price, stock, and promotions via OpenAI’s intraday API channel; the snapshot is the baseline, pas the whole plan.

2. Fabricating a GTIN to faire a field validate. A guessed or copied identifier is worse que a blank un — it matches vous contre the incorrect product à travers formats. Fix: GTIN si vous have it, sinon brand + MPN, sinon identifier_exists = false.

3. Letting feed price and checkout price drift apart. Pour ads it’s a disapproval; pour an agent mid-purchase it’s a broken sale, and it erodes the trust the whole system runs on. Fix: treat feed price as a contract — sync it to live checkout, and garder on-page schema price matching aussi.

4. Reusing or churning item_id/SKU. Si the identity clé changements entre snapshots, the agent loses continuity — votre product semble deleted and re-created, wiping accumulated matching. Fix: garder item_id stable pour the life of the product.

5. Enabling checkout sans the policy fields. Flipping is_eligible_checkout = true sans a retourner policy, privacy policy, and ToS rend vous discoverable but un-transactable. Fix: ship tout three avant vous enable checkout eligibility.

6. Treating Conversational Attributes as a substitute pour a clean base feed. A great Q&A or popularity-rank attribute doesn’t rescue a feed disapproved pour a bad price or invented GTIN. Fix: obtenir requis attributes clean premier; enrich second.

7. Assuming schema.org markup alone obtient vous into ChatGPT checkout. Pour transactional flows, ChatGPT reads the ACP feed, pas votre rendered page — markup is a cross-verification channel, pas the principal discovery mechanism pour que flow. Fix: ship the feed; garder markup consistent with it.

Rapide checks pour feed/markup consistency

Petit, copy-pasteable checks pour the mismatches que break agentic sales. Nothing ici replaces a réel feed-management platform — they’re pour spotting problems fast.

Extract on-page Product/Offer schema in le navigateur console

Paste ce into Chrome DevTools Console on a product page to pull the price and availability the agent-facing markup asserts, so vous pouvez comparer it to votre feed:

// Grab every JSON-LD block, find Product/Offer, print price + availability
[...document.querySelectorAll('script[type="application/ld+json"]')]
  .map(s => { try { return JSON.parse(s.textContent); } catch { return null; } })
  .filter(Boolean)
  .flatMap(o => Array.isArray(o) ? o : (o['@graph'] || [o]))
  .filter(o => o && /Product/.test([].concat(o['@type']).join()))
  .forEach(p => {
    const offer = [].concat(p.offers || [])[0] || {};
    console.log({
      name: p.name,
      gtin: p.gtin13 || p.gtin || p.gtin12 || p.mpn || null,
      price: offer.price ?? offer.priceSpecification?.price,
      currency: offer.priceCurrency,
      availability: offer.availability,
    });
  });

A bookmarklet version (enregistrer l’URL ci-dessous as a bookmark, click it on quelconque product page to alert the on-page price/availability):

javascript:(()=>{const b=[...document.querySelectorAll('script[type="application/ld+json"]')].map(s=>{try{return JSON.parse(s.textContent)}catch{return null}}).filter(Boolean).flatMap(o=>Array.isArray(o)?o:(o['@graph']||[o])).filter(o=>o&&/Product/.test([].concat(o['@type']).join()));if(!b.length){alert('No Product schema found');return}const p=b[0],o=[].concat(p.offers||[])[0]||{};alert(`${p.name}\nprice: ${o.price??o.priceSpecification?.price} ${o.priceCurrency||''}\navail: ${o.availability||'?'}`)})();

Comparer feed price contre live checkout price (shell)

Si vous export votre feed to CSV with item_id,price columns and have a façon to récupérer the live price per SKU, ce flags divergences — the unique la plupart damaging échec:

# feed.csv: item_id,price   |   live.csv: item_id,price (pulled from checkout)
join -t, -1 1 -2 1 \
  <(sort -t, -k1,1 feed.csv) \
  <(sort -t, -k1,1 live.csv) \
  | awk -F, '$2 != $3 { print "MISMATCH", $1, "feed="$2, "live="$3 }'

Validate ACP checkout-eligibility completeness (Python)

A minimal sanity vérifier que quelconque product flagged pour checkout carries the requis policy fields avant vous push a snapshot:

import csv

REQUIRED_FOR_CHECKOUT = ["seller_privacy_policy", "seller_tos", "return_policy"]

with open("feed.csv", newline="") as f:
    for row in csv.DictReader(f):
        if row.get("is_eligible_checkout", "").lower() == "true":
            missing = [k for k in REQUIRED_FOR_CHECKOUT if not row.get(k, "").strip()]
            if missing:
                print(f"{row['item_id']}: checkout enabled but missing {missing}")
        if row.get("is_eligible_checkout", "").lower() == "true" \
           and row.get("is_eligible_search", "").lower() != "true":
            print(f"{row['item_id']}: checkout eligible but search is not (invalid)")

Spot fabricated / malformed GTINs (regex)

An ACP gtin devrait be 8–14 digits, aucun dashes or spaces. Flag anything que isn’t:

# Prints rows whose gtin column isn't a clean 8–14 digit string
awk -F, 'NR>1 && $3 != "" && $3 !~ /^[0-9]{8,14}$/ { print "BAD GTIN:", $1, $3 }' feed.csv

Daily AI product-feed operations SOP

1. Confirmer the complet snapshot completed. Vérifier the attendu stable filename, record count, schema, and delivery status. Fait signifie the platform accepted the latest complet catalog plutôt que an accidental partial fichier.
2. Reconcile intraday changements. Comparer price, stock, and promotion updates from the commerce backend with API acknowledgements. Fait signifie every modifié SKU has soit succeeded or entered an owned retry queue.
3. Examiner eligibility and policy errors. Groupe échecs by source field and template, prioritizing products intended pour checkout. Fait signifie chaque error has a causer, owner, and correction chemin.
4. Sample cross-format parity. Comparer stable ID, GTIN/MPN, variant, price, availability, and policy valeurs à travers the Merchant Center feed, OpenAI feed, Product/Offer markup, and live checkout. Fait signifie the sampled products décrire the même offer everywhere.
5. Vérifier identity continuity. Flag item IDs que disappeared and reappeared sous nouveau valeurs sans a genuine product replacement. Fait signifie accidental SKU churn is corrected avant the suivant snapshot.
6. Fermer stale or invalid offers. Mark unavailable products correctement and utiliser the pris en charge eligibility mechanism au lieu de leaving phantom stock. Fait signifie aucun supprimé offer remains purchasable by an agent.
7. Log and trend échecs. Record mismatches, processing delays, rejected rows, and fixes by source system. Fait signifie recurring upstream defects are visible plutôt que repeatedly patched in exports.

Courant AI product-feed problèmes

Product is présent in the fichier but absent from discovery

Symptom: the row is delivered but the product n’est pas eligible or surfaced. Probable causer: is_eligible_search remains faux, the row failed validation, or identity/policy données is incomplete. Fix: inspect the platform’s row-level status, correct the failed fields, explicitly enable search eligibility, and confirmer the suivant processed snapshot accepts the item.

Checkout is unavailable pour an sinon visible product

Symptom: the product peut be recommended but ne peut pas be purchased via the agent. Probable causer: checkout eligibility is faux or requis retourner, privacy, or terms données is manquant. Fix: supply the requis policies, garder search eligibility enabled, and vérifier the processed item becomes checkout-eligible.

The agent montre the incorrect price or phantom stock

Symptom: discovery données disagrees with checkout or the item fails during purchase. Probable causer: seulement the daily snapshot is updating, an intraday event failed, or variant mapping points at the incorrect offer. Fix: reconcile API acknowledgements to the backend, replay failed updates safely, and confirmer feed, markup, and checkout agree on the exact variant.

Products repeatedly disappear and retourner as nouveau

Symptom: catalog continuity resets entre snapshots même though the merchandise did pas modifier. Probable causer: item_id is generated from a mutable title, URL, or export row rather than a stable product key. Fix: restore a durable identity map and keep the same item ID for the product’s lifetime.

A product matches the incorrect entity

Symptom: the listing inherits details or variants from a différent product. Probable causer: a fabricated/incorrect GTIN, copied MPN, or inconsistent brand and variant données. Fix: supprimer guessed identifiers, utiliser the verified GTIN or brand + MPN, and mark genuinely identifier-less items correctement.

Mental models pour AI product feeds

Un source of truth, several delivery formats

Merchant Center, OpenAI, and on-page Product/Offer markup are mappings of the même catalog, pas independent content projects. Generate les from un governed product model so identity and offer truth ne peut pas drift by channel.

Identity, offer, policy

Debug every feed in three layers:

• Identity: stable item ID, GTIN or brand + MPN, product/variant relationship.
• Offer: price, currency, availability, image, destination URL.
• Policy: shipping, renvoie, privacy, terms, and checkout eligibility.

Identity determines ce que the product is, offer determines ce que peut be bought now, and policy determines si an agent may complet the purchase.

Snapshot plus event stream

The daily complet snapshot establishes complet catalog state. Intraday API updates carry fast-changing price, stock, and promotion events. Neither replaces the autre: the snapshot heals drift, pendant que the event stream garde transactions current.

Discovery is necessary, checkout is separate

Feed quality peut faire a product understandable and eligible. It ne peut pas guarantee a recommendation or conversion, and checkout adds its propre policy, reliability, and trust requirements.

Cross-verification rewards consistency

Feeds, markup, and checkout act as independent witnesses to the même offer. Agreement builds confidence; a mismatch forces the platform to decide qui source is stale.

Ressources utiles

My connexe writing

• The Beginner’s Guide to SEO technique — où données structurées and feeds fit in the bigger picture.
• Meet the Nouveau Web Robots d’exploration: AI Bots Are Closing in on Moteur de recherche Bots — how the mix of bots reading votre site (and votre feed’s world) is shifting toward AI.

My speaking

• How Search Fonctionne (SlideShare) — my walkthrough of exploration, rendering, indexation, and ranking, utile pour grasping pourquoi feed-based discovery skips la plupart of que funnel. (My standing disclaimer: “This is my understanding of systems… not going to be 100% complete or accurate.”)

From autour the industry

• OpenAI — Product feeds overview and the required-fields spec — the principal source pour the ACP feed, vérifié directement.
• Google — Intro to Product données structurées — how feed and on-page markup combine and cross-verify.
• Shopify Enterprise — 8 tips to prepare votre product données pour AI channels (Kate Ragotte) — the strongest platform-official framing on données consistency and structure.
• Moteur de recherche Land — Pourquoi product feeds besoin an organic strategy pour AI search (Jen Cornwell, Tinuiti) — the feed as an owned asset feeding AI visibility.
• Moteur de recherche Land — The AI engine pipeline: gates que decide si vous win the recommendation (Jason Barnard, Kalicube) — pourquoi structured feeds bypass la plupart of the SEO funnel.
• PPC Land — 8 Google Merchant Center attributes votre feed nécessite pour AI Mode — the Conversational Attributes walkthrough (vérifier noms contre Google’s live docs).
• Moteur de recherche Land — Walmart: ChatGPT checkout converted worse que website — the discovery-vs-conversion caveat.
• Striim — Retail’s AI problem isn’t the model, it’s the clock — a clean analogy pour pourquoi batch inventory syncs échouer agents que besoin near-real-time reads.

Testez vos connaissances: Product Feeds pour AI

Five rapide questions on building a feed AI agents peut lire and buy from. Pick an réponse pour chaque, alors vérifier.

Journal des modifications