Product Feeds for AI

TL;DR — A product feed for AI is a structured file — a list of your products with their prices, stock, identifiers, and policies — that supported AI shopping tools can use alongside other merchant data. Accurate, complete feeds can make products eligible for commerce experiences; stale data can disrupt them. Getting the identifiers right (the barcode-style GTIN, or brand + part number) and keeping price and stock current is most of the job.

What a product feed for AI actually is

When a person shops, they open your web page, read it, and decide. When an AI shopping agent shops on someone’s behalf, it mostly works from a feed instead — a structured file with a row for every product and columns describing it: title, price, availability, image, brand, an ID number, and your policies.

How far that goes depends on who’s reading. For ChatGPT’s commerce flows, OpenAI’s own docs describe the feed as the way merchants supply product data — there’s no documented fallback to crawling your page. Google is different: its own docs say Google combines crawling, on-page structured data, and your Merchant Center feed, so the feed doesn’t replace your HTML there — it’s one of three channels Google cross-checks against each other. Either way, the practical takeaway holds: the thing most likely to decide whether your products get recommended isn’t your page copy on its own — it’s the data in that file.

Why this is a little different from a normal Shopping feed

If you already send a feed to Google Merchant Center, you have a big head start — it’s the same kind of file. What changes is the reader, and readers have different tolerances:

• A search result can show a slightly old price, because a human clicks through and double-checks on your site before paying.
• An AI agent completing a purchase can’t do that. It acts on the number in your feed. If your feed says $40 and checkout says $45, that’s a real risk of a broken transaction, not a minor mismatch a human will shrug off.

So the two things that matter most are: get the identifiers right, and keep price and stock accurate and fresh.

The three files you’ll hear about

You don’t pick one — bigger stores run all three, because they reach different AI tools:

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 file ChatGPT reads for shopping and checkout.
3. schema.org Product/Offer markup — the structured data on your page, used as a backup that other systems cross-check against your feed.

The one thing not to do

Never make up a GTIN or product fact to fill a field. Google’s own rule is explicit: don’t guess, and don’t copy a value from a similar product. A wrong identifier makes an agent match you to the wrong product — worse than leaving it blank.

Want the field-by-field version — the OpenAI spec, Google’s new AI-only attributes, the schema.org properties agents use to check out, and the exact failures that break an agentic sale? Switch to the Advanced tab.

TL;DR — There’s no single universal “AI feed” — each provider’s contract differs. For ChatGPT’s commerce flows, OpenAI documents the feed as the way you supply product data, with no stated crawling fallback; Google’s own docs describe combining crawling, on-page structured data, and your Merchant Center feed together, not one replacing the other. 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 full snapshot plus an intraday API for price, stock, and promotions), and schema.org Product/Offer markup as a cross-verification layer. Identifiers (GTIN, or brand + MPN) are the backbone across all three; never fabricate one. The real differentiator versus a Shopping-ads feed is staleness tolerance: a human double-checks a price before buying, an agent commits programmatically — so feed/checkout price mismatch, phantom stock, a missing return policy blocking checkout eligibility, or an unstable item_id is a real 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, not open to everyone. And feed quality drives discovery and eligibility, not conversion.

There’s no one universal “AI feed” — providers differ

I keep coming back to one framing because it reorganizes everything else, but it needs a caveat I didn’t give it strongly enough before: this isn’t one universal behavior, it’s a provider-specific contract.

For ChatGPT’s commerce flows, OpenAI’s own docs describe the feed as the way merchants supply product data — there’s no documented fallback to crawling your rendered page for that flow. For Google, it’s genuinely different: Google’s Search Central docs are explicit that Google combines crawling, on-page structured data, and your Merchant Center feed — “Google may at times use other approaches to extract data from pages” alongside both of the others — so the feed doesn’t replace your HTML there, it’s one of three channels Google cross-checks against each other. The Agentic Commerce Protocol piece covers the ACP-specific mechanics in depth and I won’t re-derive that here. This article is the practical layer under it: what you actually put in the file, across the formats that matter, and what breaks a sale when you get it wrong.

The mechanism is still worth stating plainly because it changes your priorities, even with that caveat. Jason Barnard put it well in his AI-engine pipeline piece: structured feeds — Google Merchant Center and OpenAI’s Product Feed Specification — “bypass discovery, selection, crawling, and rendering altogether, delivering your content to the competitive phase with minimal attenuation.” That’s Barnard’s own framing of how a good feed can skip most of the SEO funnel, not a claim either platform makes in its docs — but it’s a useful mental model. The downside is that everything now rides on data quality, and there’s no rendered page for a human to sanity-check against mid-transaction the way there is with a search result.

Three formats, not one

A serious merchant doesn’t choose between these — they run all three at once, because each reaches a different set of agents and they cross-verify each other.

The synthesis point: these aren’t competing choices. Google explicitly blends feed data and on-page structured data — “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,” and some experiences will pull, say, pricing from your feed when it’s missing from your markup. Which also means a mismatch between the two — feed price says one thing, on-page schema says another — is a trust-erosion and disapproval risk in every one of these systems. Google/Shopify’s UCP leans on the same Merchant Center feed as its data backbone, so this work pays off there too.

The OpenAI ACP feed spec, field by field

This is the part most competing write-ups paraphrase secondhand. Here’s what OpenAI’s own product-feed spec actually requires (verified against the live docs):

Required fields

• item_id — max 100 chars, and it must stay stable over time. This is the continuity key between snapshots; change it and the agent thinks the old product vanished and a new one appeared.
• title — max 150 chars, avoid all-caps.
• description — max 5,000 chars, plain text only.
• url — must 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 false. You have to explicitly flip this to true to appear in ChatGPT search at all.
• is_eligible_checkout — boolean; requires is_eligible_search = true.

Conditional requirements

• availability_date is required if availability = pre_order.
• seller_privacy_policy and seller_tos are required if is_eligible_checkout = true.
• A return policy is required for checkout eligibility.

One scope caveat worth flagging: flipping is_eligible_checkout to true makes a product checkout-eligible in the feed, but it doesn’t by itself get you into ChatGPT checkout. Per OpenAI’s own docs, Instant Checkout in ChatGPT is currently limited to approved partners — you apply to participate — and even once approved, the merchant (not OpenAI) still performs order validation, determines fulfillment, calculates and charges tax, runs its own risk checks, charges the payment method through its own processor, and accepts or declines the order. OpenAI’s UI renders the session; your systems still own the transaction.

Identifiers. gtin (numeric, 8–14 digits, no dashes or spaces — it accepts GTIN/UPC/ISBN in one field) is optional but strongly recommended; mpn (alphanumeric, max 70) is the fallback when GTIN is unavailable. Neither is “required” the way brand is, but OpenAI’s framing is that supplying them improves catalogue matching and reduces errors — functionally the same logic as Google’s GTIN-or-brand+MPN rule, just phrased as a strong recommendation.

The “15-minute update” myth — what OpenAI actually documents

Here’s a number I couldn’t verify, and I’d rather flag it than repeat it. Across trade coverage — and, I’ll admit, in an earlier version of our own ACP article — you’ll see the claim that OpenAI requires feeds to update every 15 minutes. I went looking for it in OpenAI’s current commerce docs and couldn’t find that figure stated anywhere.

What the docs actually describe is a two-channel model, not a flat interval:

• A full feed snapshot at least once a day, delivered as a file upload over SFTP using stable filenames that you overwrite (not versioned new files each time).
• An API channel for intraday incremental updates — this is how price, stock, and (specifically) promotions changes propagate faster than the daily snapshot. Promotions data is API-only.

OpenAI’s own wording is roughly: provide the entire feed once a day via file upload, then send updates throughout the day via the API. There’s no separate “delete” call either — to pull a product you set is_eligible_search = false or drop it from the next full snapshot.

So “15 minutes” is best treated as a practitioner rule-of-thumb for how fresh your fast-moving SKUs should be, not a documented OpenAI requirement. The spec is versioned and moving fast, so check the current version before you quote any number — but the mechanism you should actually build for is daily snapshot + intraday API, and that’s more useful than the myth anyway.

Why real-time accuracy is non-negotiable for agents

This is the real difference between AI-feed work and Shopping-ads-feed work, and it’s worth being precise about why. A cached search snippet tolerates a little staleness because there’s a human in the loop who lands on your page and re-checks before paying. An agent completing a transaction has no such buffer — it acts on the price and stock state your feed asserts, so a stale value there is a real risk to the transaction in a way a stale search snippet isn’t. No official spec states that every stale value automatically breaks every transaction, and providers add validation steps of their own on top of the feed — but the mechanism itself (no human re-check before committing) is exactly why freshness matters more here than it does for an ad snippet.

Kate Ragotte, in Shopify’s enterprise guidance on preparing product data for AI channels, puts the consequence bluntly: “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.” And on why structure matters at all: “AI agents can only recommend what they can understand, and that depends entirely on how well-structured your product data is” — machines can technically find loosely-structured information, “but they won’t confidently act on it. AI agents prefer structured, labeled data they can extract and trust.”

That’s the whole game: the agent has to trust the number enough to transact on it. The daily-snapshot-plus-intraday-API model is OpenAI’s concrete answer to closing the gap; on the Google side it’s the Shopping Graph, which Google says now includes “more than 50 billion product listings, 2 billion of which are updated every hour” — that hourly refresh benchmark is the pace the system expects your data to move at. (The Shopping Graph as a system is its own topic; this article just assumes your feed populates it.)

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

On the Google side, the specific thing that’s new for AI is a set of optional Merchant Center attributes announced at Google Marketing Live in May 2026, covered by Search Engine Land. The point of them is that Google’s AI systems “use that structured data to better match products with conversational shopping queries across AI Mode, Gemini and other AI-powered surfaces.” Google’s own attribute-help wording, as reported, is that these are “primarily intended for use in conversational experiences such as AI Mode in Google Search.”

Google’s Merchant Center Help documents six conversational attributes: question and answer, document link, related product, item group title, variant option, and popularity rank. product_highlight and product_detail are existing, pre-existing complementary fields — not two additional members of the new conversational set, despite that being how some trade coverage (including an earlier version of this article) grouped them.

Google is explicit that these are optional and that adding them doesn’t affect your existing product-approval status; the framing is that they can help product understanding and discovery in conversational surfaces, not that they’re required or that they guarantee inclusion, ranking, or citation in any AI Mode/Gemini response.

Frame these as enrichment, not a replacement. They sit on top of your required attributes. If your base feed is disapproved for a bad price or a fabricated GTIN, a beautiful Q&A attribute doesn’t save you.

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

There is no “AI edition” of schema.org — the properties agents rely on are ordinary ecommerce vocabulary being read by a new class of consumer. Three matter most:

• Offer.availability — “The availability of this item — for example In stock, Out of stock, Pre-order, etc.” The stock state an agent reads from your markup.
• Offer.checkoutPageURLTemplate — “A URL template (RFC 6570) for a checkout page for an offer.” This is the property that lets an agent route a shopper to a pre-filled checkout from your markup alone.
• Offer.acceptedPaymentMethod — the payment methods you accept, which an agent may check before attempting a transaction.

Keep this markup’s price and availability in lockstep with your feed. Google blends the two and cross-verifies them, so a divergence between on-page schema and feed is exactly the kind of inconsistency that erodes trust across all these surfaces.

Feed-quality failures that break agentic discovery and checkout

This is the practical payoff. These are the specific things that break an AI sale — not just an ad disapproval:

1. Feed/checkout price mismatch. The feed says $40, checkout says $45. For ads it’s a disapproval; for 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 that isn’t there.
3. Missing or wrong identifiers. No GTIN/MPN, or a fabricated one, causes the agent to mismatch you against the wrong product across formats. Google’s rule: don’t make up, guess, or copy identifiers from similar products; use identifier_exists = false for genuinely identifier-less goods.
4. Missing return policy or seller ToS. In the ACP spec these are required for is_eligible_checkout = true. Omit them and you’re discoverable but can’t transact.
5. Unstable item_id/SKU. If the identity key changes between snapshots, the agent loses continuity — the old product looks deleted and the new one looks unknown, wiping any accumulated matching.
6. ALL-CAPS or promotional text in titles. A policy violation across Google and OpenAI alike (OpenAI’s spec says avoid all-caps outright).
7. AI-generated images or descriptions with drift. Descriptions that invent specs not on the landing page, or AI-generated images missing required IPTC disclosure metadata, break the cross-verification between feed and page. (The feed-optimization guide covers the “don’t invent facts” rule in depth.)

What feed quality does and doesn’t guarantee

One honest caveat so you don’t overclaim internally: a great feed gets you discovered and eligible. It does not guarantee conversion. Walmart’s own reported experience is the cleanest data point here — per Search Engine Land, its in-chat ChatGPT checkout converted at roughly one-third the rate of click-out transactions after testing around 200,000 items. Read the reporting carefully: the cited cause was checkout UX and trust (fear of split shipments, single-item-only checkout) — not feed data staleness. So don’t use it as evidence that feeds fail; use it as the reminder that getting into the feed is necessary, not sufficient. Discovery and checkout conversion are separate problems.

It’s worth keeping the whole chain separate in your head, because “my feed is accepted” answers a much narrower question than it sounds like: ingestion (the platform accepted your file) is not validation (it passed the field/policy checks), which is not eligibility (is_eligible_search/is_eligible_checkout are set and approved), which is not display (an agent actually surfaces the product), which is not ranking or citation (it’s the one recommended), which is not checkout approval (you’re an approved Instant Checkout partner), which is not conversion (the shopper buys). A clean feed raises your odds at every step; it doesn’t collapse the chain into one guaranteed outcome.

Where this fits

• Agentic Commerce Protocol — the protocol itself and its five building blocks (Product Feed is one of them).
• Universal Commerce Protocol — Google/Shopify’s counterpart, same 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 data I won’t repeat here.

AI summary

A condensed take on the Advanced version:

• No single universal “AI feed.” For ChatGPT’s commerce flows, OpenAI documents the feed as the way you supply product data, with no stated crawling fallback. For Google, the feed doesn’t replace crawling — Google’s docs describe combining crawling, on-page structured data, and your Merchant Center feed together.
• Run three formats, not one: Google Merchant Center feed, OpenAI ACP feed spec, and schema.org Product/Offer markup. Google blends feed + on-page structured data and cross-verifies them, so a mismatch between them is a trust/disapproval risk.
• Identifiers are the backbone. GTIN, or brand + MPN, across every format. Never fabricate one; use identifier_exists = false for goods without one.
• Real-time accuracy is the real differentiator. A human double-checks a price before buying; an agent commits programmatically. A feed/checkout price mismatch or phantom stock is a real risk to the transaction, though no spec guarantees every stale value breaks every sale.
• The “15-minute update” figure isn’t in OpenAI’s docs. The documented model is a daily full snapshot (SFTP, stable filenames, overwrite) + an intraday API for price/stock/promotions. Promotions are API-only.
• ACP required fields include stable item_id, title, description, url, brand, image_url, price (ISO 4217), availability enum, seller fields, country fields, and is_eligible_search (defaults false — must be flipped true). is_eligible_checkout also needs a return policy, privacy policy, and ToS — and even then, 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 answer, document link, related product, item group title, variant option, and popularity rank. (product_highlight and product_detail are pre-existing fields, not part of this new set.) Adding them doesn’t affect existing product-approval status.
• schema.org’s agent-facing properties: Offer.availability, checkoutPageURLTemplate, acceptedPaymentMethod.
• Feed quality drives discovery and eligibility, not conversion — and ingestion, validation, eligibility, display, ranking/citation, checkout approval, and conversion are each separate steps. Walmart’s in-chat ChatGPT checkout converted ~3x worse than click-out — attributed to checkout UX/trust, not feed staleness.

Official documentation

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

OpenAI (Agentic Commerce Protocol)

• Product feeds overview — the ACP feed at a glance.
• Product feed spec — required fields — the field-by-field requirements.
• Feed concept page — delivery, format, and snapshot/API model.
• Commerce key concepts — how a feed fits into ChatGPT search and checkout.

Google

• Product data specification — the base Merchant Center attribute spec the AI surfaces inherit.
• Unique product identifiers (GTIN, MPN, brand) — the identifier rules, including “don’t make up, guess, or include values from similar products.”
• Intro to Product structured data — how Google blends feed and on-page structured data.
• Agentic commerce AI tools & protocol for retailers — Google’s own framing for AI-facing retailer tooling.
• Agentic checkout / holiday AI shopping — the Shopping Graph scale/freshness benchmark (50B listings, 2B updated 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 data quality

• “Providing accurate and correctly formatted product data is essential for creating successful ads.” — Google Merchant Center Help. 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 structured data together

• “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. Read 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.” Read 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.” Read the article

Jason Barnard, Kalicube (Search Engine 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.” Read the article

Jen Cornwell, Tinuiti (Search Engine 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.” Read the article

Cross-format AI-feed audit checklist

A single pass across all three formats before you call a feed “AI-ready”:

Identity & matching

• Every product that has a GTIN carries a correct one; nothing fabricated or copied from a similar product.
• Products without a manufacturer identifier use brand + MPN, or identifier_exists = false — never a guessed GTIN.
• item_id/SKU is stable over time and consistent across feed, ACP, and markup.

Price & availability (the freshness layer)

• Feed price matches live checkout price; currency is a valid ISO 4217 code.
• Availability reflects real stock — no phantom in_stock.
• Fast-moving SKUs update via the ACP intraday API, not just the daily snapshot; promotions go through the API.
• On-page schema price/availability matches the feed (Google cross-verifies them).

ACP checkout eligibility

• is_eligible_search is explicitly true (it defaults false).
• is_eligible_checkout products have a return policy, seller_privacy_policy, and seller_tos.
• availability_date set for any pre_order items.
• Feed delivered by SFTP with stable filenames you overwrite, full snapshot at least daily.

Content & compliance

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

Enrichment (optional)

• Google’s six Conversational Attributes added where they fit (Q&A, popularity rank, related product, item group title, variant option, document link) — on top of, not instead of, required attributes.
• schema.org checkoutPageURLTemplate present so agents can route to checkout.

AI product feed — cheat sheet

Which format reaches which agent

ACP required fields (fast reference)

• item_id (stable), title (≤150, no 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 false), is_eligible_checkout.
• Checkout also needs: return policy, seller_privacy_policy, seller_tos.
• availability enum: in_stock, out_of_stock, pre_order, backorder, unknown.

Identifier rule (all formats)

• Has a GTIN → use it (8–14 digits, no dashes/spaces).
• No GTIN → brand + MPN.
• Genuinely none → identifier_exists = false. Never fabricate.

Myth-buster

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

Which identifier do I put in my feed?

Identifiers are the backbone across Google, OpenAI, and schema.org — and the single easiest thing to get wrong. Answer a question or two and land on the right value.

What not to do with an AI feed

1. Building for the daily snapshot only and skipping the API. If you push a full feed once a day and stop there, every price cut and stock change is up to 24 hours stale — fine for browsing, fatal for a transaction. Fix: wire price, stock, and promotions through OpenAI’s intraday API channel; the snapshot is the baseline, not the whole plan.

2. Fabricating a GTIN to make a field validate. A guessed or copied identifier is worse than a blank one — it matches you against the wrong product across formats. Fix: GTIN if you have it, else brand + MPN, else identifier_exists = false.

3. Letting feed price and checkout price drift apart. For ads it’s a disapproval; for 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 keep on-page schema price matching too.

4. Reusing or churning item_id/SKU. If the identity key changes between snapshots, the agent loses continuity — your product looks deleted and re-created, wiping accumulated matching. Fix: keep item_id stable for the life of the product.

5. Enabling checkout without the policy fields. Flipping is_eligible_checkout = true without a return policy, privacy policy, and ToS makes you discoverable but un-transactable. Fix: ship all three before you enable checkout eligibility.

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

7. Assuming schema.org markup alone gets you into ChatGPT checkout. For transactional flows, ChatGPT reads the ACP feed, not your rendered page — markup is a cross-verification channel, not the primary discovery mechanism for that flow. Fix: ship the feed; keep markup consistent with it.

Quick checks for feed/markup consistency

Small, copy-pasteable checks for the mismatches that break agentic sales. Nothing here replaces a real feed-management platform — they’re for spotting problems fast.

Extract on-page Product/Offer schema in the browser console

Paste this into Chrome DevTools Console on a product page to pull the price and availability the agent-facing markup asserts, so you can compare it to your 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 (save the URL below as a bookmark, click it on any 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||'?'}`)})();

Compare feed price against live checkout price (shell)

If you export your feed to CSV with item_id,price columns and have a way to fetch the live price per SKU, this flags divergences — the single most damaging failure:

# 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 check that any product flagged for checkout carries the required policy fields before you 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 should be 8–14 digits, no dashes or spaces. Flag anything that 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. Confirm the full snapshot completed. Check the expected stable filename, record count, schema, and delivery status. Done means the platform accepted the latest complete catalog rather than an accidental partial file.
2. Reconcile intraday changes. Compare price, stock, and promotion updates from the commerce backend with API acknowledgements. Done means every changed SKU has either succeeded or entered an owned retry queue.
3. Review eligibility and policy errors. Group failures by source field and template, prioritizing products intended for checkout. Done means each error has a cause, owner, and correction path.
4. Sample cross-format parity. Compare stable ID, GTIN/MPN, variant, price, availability, and policy values across the Merchant Center feed, OpenAI feed, Product/Offer markup, and live checkout. Done means the sampled products describe the same offer everywhere.
5. Check identity continuity. Flag item IDs that disappeared and reappeared under new values without a genuine product replacement. Done means accidental SKU churn is corrected before the next snapshot.
6. Close stale or invalid offers. Mark unavailable products correctly and use the supported eligibility mechanism instead of leaving phantom stock. Done means no removed offer remains purchasable by an agent.
7. Log and trend failures. Record mismatches, processing delays, rejected rows, and fixes by source system. Done means recurring upstream defects are visible rather than repeatedly patched in exports.

Common AI product-feed issues

Product is present in the file but absent from discovery

Symptom: the row is delivered but the product is not eligible or surfaced. Likely cause: is_eligible_search remains false, the row failed validation, or identity/policy data is incomplete. Fix: inspect the platform’s row-level status, correct the failed fields, explicitly enable search eligibility, and confirm the next processed snapshot accepts the item.

Checkout is unavailable for an otherwise visible product

Symptom: the product can be recommended but cannot be purchased through the agent. Likely cause: checkout eligibility is false or required return, privacy, or terms data is missing. Fix: supply the required policies, keep search eligibility enabled, and verify the processed item becomes checkout-eligible.

The agent shows the wrong price or phantom stock

Symptom: discovery data disagrees with checkout or the item fails during purchase. Likely cause: only the daily snapshot is updating, an intraday event failed, or variant mapping points at the wrong offer. Fix: reconcile API acknowledgements to the backend, replay failed updates safely, and confirm feed, markup, and checkout agree on the exact variant.

Products repeatedly disappear and return as new

Symptom: catalog continuity resets between snapshots even though the merchandise did not change. Likely cause: 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 wrong entity

Symptom: the listing inherits details or variants from a different product. Likely cause: a fabricated/incorrect GTIN, copied MPN, or inconsistent brand and variant data. Fix: remove guessed identifiers, use the verified GTIN or brand + MPN, and mark genuinely identifier-less items correctly.

Mental models for AI product feeds

One source of truth, several delivery formats

Merchant Center, OpenAI, and on-page Product/Offer markup are mappings of the same catalog, not independent content projects. Generate them from one governed product model so identity and offer truth cannot 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, returns, privacy, terms, and checkout eligibility.

Identity determines what the product is, offer determines what can be bought now, and policy determines whether an agent may complete the purchase.

Snapshot plus event stream

The daily full snapshot establishes complete catalog state. Intraday API updates carry fast-changing price, stock, and promotion events. Neither replaces the other: the snapshot heals drift, while the event stream keeps transactions current.

Discovery is necessary, checkout is separate

Feed quality can make a product understandable and eligible. It cannot guarantee a recommendation or conversion, and checkout adds its own policy, reliability, and trust requirements.

Cross-verification rewards consistency

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

Resources worth your time

My related writing

• The Beginner’s Guide to Technical SEO — where structured data and feeds fit in the bigger picture.
• Meet the New Web Crawlers: AI Bots Are Closing in on Search Engine Bots — how the mix of bots reading your site (and your feed’s world) is shifting toward AI.

My speaking

• How Search Works (SlideShare) — my walkthrough of crawling, rendering, indexing, and ranking, useful for grasping why feed-based discovery skips most of that funnel. (My standing disclaimer: “This is my understanding of systems… not going to be 100% complete or accurate.”)

From around the industry

• OpenAI — Product feeds overview and the required-fields spec — the primary source for the ACP feed, checked directly.
• Google — Intro to Product structured data — how feed and on-page markup combine and cross-verify.
• Shopify Enterprise — 8 tips to prepare your product data for AI channels (Kate Ragotte) — the strongest platform-official framing on data consistency and structure.
• Search Engine Land — Why product feeds need an organic strategy for AI search (Jen Cornwell, Tinuiti) — the feed as an owned asset feeding AI visibility.
• Search Engine Land — The AI engine pipeline: gates that decide whether you win the recommendation (Jason Barnard, Kalicube) — why structured feeds bypass most of the SEO funnel.
• PPC Land — 8 Google Merchant Center attributes your feed needs for AI Mode — the Conversational Attributes walkthrough (verify names against Google’s live docs).
• Search Engine Land — Walmart: ChatGPT checkout converted worse than website — the discovery-vs-conversion caveat.
• Striim — Retail’s AI problem isn’t the model, it’s the clock — a clean analogy for why batch inventory syncs fail agents that need near-real-time reads.

Test yourself: Product Feeds for AI

Five quick questions on building a feed AI agents can read and buy from. Pick an answer for each, then check.

Product Feeds for AI

A product feed for AI is a structured, machine-readable export of your catalog — identifiers, pricing, availability, and policies — built for AI shopping agents and LLMs to read and transact against directly, rather than for a human browsing a page or a search index.

Related: Agentic Commerce Protocol (ACP), Google Merchant Center Feed Optimization

Product Feeds for AI

A product feed for AI is the structured data file — titles, prices, availability, identifiers, images, and policies — that AI shopping agents (ChatGPT via the Agentic Commerce Protocol, Google’s AI Mode and Gemini via the Shopping Graph, and similar LLM-driven shopping surfaces) read to discover, recommend, and buy products. How much this replaces your page depends on the provider: OpenAI’s own docs describe the feed as the way merchants supply ChatGPT commerce data, with no documented crawling fallback, while Google’s docs describe combining crawling, on-page structured data, and your Merchant Center feed together rather than one replacing the others.

Mechanically it’s the same class of file you already send Google Merchant Center, but with a different reader in mind. That changes the priorities. A cached search snippet can tolerate a slightly stale price because a human double-checks on the page before buying; an agent completing a transaction commits to a price and stock state programmatically, so feed accuracy and freshness become the thing that determines whether your products can be recommended and bought at all.

In practice a serious merchant reconciles three parallel formats: the Google Merchant Center feed (feeds the Shopping Graph, and now Google’s optional AI-facing Conversational Attributes), OpenAI’s ACP product feed spec (a Parquet/JSONL export delivered by SFTP, with a daily full snapshot plus an intraday API channel for price, stock, and promotions), and schema.org Product/Offer markup on the page as a secondary cross-verification channel. The common backbone across all three is correct identifiers — GTIN, or brand plus MPN — which should never be fabricated.

Related: Agentic Commerce Protocol (ACP), Google Merchant Center Feed Optimization

Changelog