In the previous post we covered how to get an AI to choose you: evidence, extractable writing, and third-party corroboration. But there is a step underneath all of that. Even the most persuasive, best-sourced page is invisible if an agent cannot read it. AI buyers do not experience your store the way a human does. They do not see the hero image, the sticky "Add to cart" button, or the carousel of lifestyle shots. They ingest data: a product's title, price, availability, identifiers, and attributes. This post is about handing them that data cleanly, in the places they actually look.
Why agents read your data, not your design
A shopper and an agent land on the same product page and take away completely different things. The human sees a photo, a price in a nice font, a few reviews, and a button. The agent sees the page's underlying HTML and structured data. If your price only appears after a client-side script fires, or your reviews load in a widget that renders in the browser, the agent may read a page that looks, to it, nearly empty.
This is not hypothetical. Analysis by Botify, reported via Modern Retail in June 2026, found that AI bot traffic to retail sites grew more than fivefold from 2024 to 2025, and that JavaScript-heavy elements like image carousels and review modules are almost never seen by those agents. The agents are arriving in force, and they are reading a stripped-down version of your page. What is not in the server-rendered HTML or the structured data effectively does not exist to them.
Make your catalog machine-readable: the three channels
There is no single switch for this. You expose your product data through a few complementary channels, and the strongest merchants cover all of them. Here is what each one is and why it matters.
Schema.org Product markup (the baseline)
On every product page, embed Schema.org
Product structured data as JSON-LD: name, brand, description, an offers block with price,
currency, and availability, plus identifiers like GTIN, MPN, or SKU, and aggregateRating if
you show reviews. This is the same markup search engines have used for years, and it is the fastest way
to state your product as unambiguous facts on the page itself. The rule is simple: the markup must mirror
what is visibly on the page. Never mark up a price or a rating a shopper cannot see.
Why it works: it gives an agent the product's key attributes right where it lands, without having to infer them from copy. This is the sixth of the 7 pillars of GEO, machine-readability, applied to a product.
A clean Merchant Center feed (coverage and freshness)
Google explicitly recommends providing product data in two ways at once: structured data on your pages and a product feed through Google Merchant Center. The feed gives Google a complete, current copy of your catalog, with prices and stock it can refresh on a schedule, which now feeds Google's Shopping Graph and its AI shopping surfaces. Google has also been adding conversational attributes in Merchant Center so your feed can answer the more natural, question-shaped queries shoppers put to AI.
Do this: keep the feed complete and accurate. Missing GTINs, stale prices, and "out of stock" errors are the quiet reasons products get dropped from AI answers.
The ACP product feed (to be buyable in ChatGPT)
To be eligible for ChatGPT's Instant Checkout, you provide a product feed in the format defined by the Agentic Commerce Protocol, published by OpenAI and Stripe on September 29, 2025. The feed specification expects a defined set of structured fields per item, including a unique item identifier, title, description, link, price, availability, and identifiers such as GTIN where they apply. We mapped where ChatGPT and the other surfaces fit in the shopping-aisle post; this is the data you feed the ChatGPT one specifically.
The takeaway: being buyable inside ChatGPT is a data-quality problem. Every required field has to be present, accurate, and current, or the product simply is not eligible.
The new product page: built for machines, not just shoppers
Feeds and markup get your data into the pipes. But agents also visit the live page to verify price, specs, and availability, and this is where a lot of modern storefronts fall down. Modern Retail reported in June 2026 that retailers are actively rethinking product pages because so much of the important content is locked inside JavaScript that agents do not execute. The fix is not a redesign for humans; it is making sure the facts survive without a browser.
What to change
- Put the critical facts in server-rendered HTML. Price, variants, stock status, and key specs should be present in the page source, not injected after the fact by client-side scripts. A static site does this by default; a heavy single-page app often does not.
-
Give reviews and specs a text version. If your ratings and Q&A live only in a
third-party widget, add a plain-HTML summary (and mark it up with
aggregateRating) so agents can read the social proof that so often decides a recommendation. - Add a real FAQ block. Question-shaped, self-contained answers about sizing, materials, shipping, and returns are some of the easiest content for an AI to extract and quote. Make them visible on the page, then mirror them in FAQ structured data.
- Write descriptions as facts, not just vibes. "Machine-washable, 100% merino, 18.5 micron" is more useful to an agent than "luxuriously soft and effortlessly cool." Keep the brand voice, but make sure the specifications are actually stated.
Do this now: the agent-readability audit
You can check the worst of it in an afternoon. For your top few products, run this pass:
- View the raw HTML. Open the page source (not the rendered inspector) and search for the price. If it is not there, an agent may not see it either.
- Validate your Product markup. Run a product page through a structured-data validator and confirm name, price, availability, and identifiers are present and match the page.
- Audit your Merchant Center feed. Check for missing GTINs, disapprovals, stale prices, and stock mismatches. These are the silent disqualifiers.
- Rescue reviews and specs from JS. Anything important that only appears after scripts run should also exist as plain, server-rendered HTML.
- Add or expose an FAQ on the page, and mark it up so it mirrors the visible text exactly.
- Prepare an ACP-shaped feed if you want to be buyable in ChatGPT, so the required fields are ready when your platform enables it.
None of this is glamorous, and that is the point. Machine-readability is infrastructure: unglamorous, high-leverage, and mostly invisible until it is missing. Next in the series we move from being read to being transacted: what it actually takes for an agent to check out from you, and how to do it without handing over your payments or your customer.
Frequently asked questions
What does it mean to make a product catalog machine-readable?
It means exposing your product data as clean, structured facts an AI can parse without guessing: a product's title, price, availability, GTIN or SKU, brand, and attributes stated in a defined format rather than buried in images, marketing copy, or JavaScript. The three main channels are Schema.org Product markup embedded in the page, a Merchant Center product feed submitted to Google, and, for ChatGPT, an Agentic Commerce Protocol product feed. Machine-readable data is what lets an agent confidently recommend and transact your products instead of skipping them.
Do I need both structured data on the page and a product feed?
Yes, and Google explicitly recommends both. On-page Schema.org Product markup helps AI and search understand the product where a shopper (or agent) actually lands, while a Merchant Center feed gives Google a clean, complete copy of your catalog with prices and availability it can trust and refresh. They reinforce each other: the feed provides coverage and freshness, the markup provides context on the live page. For ChatGPT's Instant Checkout you additionally need an ACP product feed.
Why are AI agents missing my product details?
Usually because the details live in JavaScript-rendered widgets that agents do not execute. Analysis by Botify reported via Modern Retail in June 2026 found that AI bot traffic to retail sites grew more than fivefold from 2024 to 2025, but that JS-heavy elements such as image carousels and review modules are almost never seen by those agents. If your price, variants, specs, or reviews only appear after client-side JavaScript runs, an agent may read a nearly empty page. Put the critical facts in server-rendered HTML and structured data.
What fields does the ChatGPT (ACP) product feed require?
The Agentic Commerce Protocol product feed, published by OpenAI and Stripe on September 29, 2025, expects a defined set of structured fields per item, including a unique item identifier, title, description, a link, price, availability, and identifiers such as GTIN where applicable. The exact schema is in OpenAI's commerce product feed specification. The takeaway for merchants is that being buyable inside ChatGPT is a data-quality problem: every required field must be present, accurate, and current for a product to be eligible.
Sources & further reading: Schema.org: Product, Google Search Central: product structured data, OpenAI: commerce product feed specification, and Modern Retail: AI forces retailers and brands to rethink their product pages. Traffic figures are drawn from the cited Botify analysis and reflect the conditions those researchers measured; treat them as directional, not guarantees.