Structured Data
Product schema in the AI era: why your store's JSON-LD is now table stakes
AI shopping agents don't browse — they parse. Product JSON-LD is table stakes for being read correctly, but it is not how you get into ChatGPT Shopping: that runs on merchant feeds. Here's the difference, and why it matters for where you spend the hour.
On this page
When a user asks ChatGPT 'what are the best sustainable running shoes under $150?', the model doesn't open a browser and shop. It draws from training data and, increasingly, from real-time agent-browsing where AI tools fetch product pages and extract structured information. What they find — or don't find — determines whether your products appear in AI-generated recommendations.
Product schema is JSON-LD embedded in your page HTML that declares product name, price, availability, ratings, brand, and identifiers in a machine-readable format. Google has used it for rich results since 2012. It is what lets an agent read your page correctly without running JavaScript — and that is a real job. What it is not is the route into AI shopping results.
Where AI shopping results actually come from
This is the part most structured-data advice gets wrong, and it changes where the hour is best spent. ChatGPT Shopping is not a direct crawl of your product pages. Its product data arrives through feeds: OpenAI's own merchant product feed specification — a push, over HTTPS, to an allow-listed endpoint, refreshable every 15 minutes — and Google Shopping, which supplies the large majority of the shopping carousel. OpenAI's crawler indexing your product pages is a third path, and the weakest of the three.123
| Path | What carries the data | What your JSON-LD does here |
|---|---|---|
| Merchant feed (OpenAI Agentic Commerce) | Pushed feed: GTIN or MPN, price + currency, availability, shipping, variants | Nothing directly — the feed is the record. Schema helps keep it consistent |
| Google Shopping → ChatGPT carousel | Google Merchant Center feed, ranked by Google organic signals | Validates and reconciles the feed; it does not replace it |
| Crawler-indexed product page | OpenAI/Bing crawl of your server-rendered HTML | This is where JSON-LD does its real work — parse-correctness |
Perfect on-page schema does not get a product into ChatGPT Shopping if the product is not in the feed with matching identifiers.
The practical consequence: if your products are missing from AI shopping surfaces, the first thing to check is your merchant feed and your GTINs — not your markup. Feed identifiers are mandatory (a valid GTIN or MPN unless the product genuinely has none), and identifier gaps are the common failure. Schema still earns its place on the third path and in keeping the other two honest, which is exactly what 'table stakes' means: necessary to be read correctly, not sufficient to be found.
What AI agents actually extract from a product page
When an AI agent visits a product page, it issues an HTTP GET — the same request a curl command makes. It receives the server-rendered HTML. On a well-built commerce site, embedded somewhere in that HTML is a `<script type="application/ld+json">` block containing the product's canonical data.
An agent looking at a product page wants:
- name — the canonical product name
- offers — current price, currency, and availability (InStock / OutOfStock)
- image — at least one image URL for visual context
- description — a text description the agent can cite or summarize
- brand — brand name for attribution
- aggregateRating — review score and count (trust signal)
- sku or gtin13 — product identifiers for comparison across retailers
If that JSON-LD block is missing, an agent fetching the page has to parse free-form HTML — unreliable — or come away with nothing. That is a legibility cost, and it is worth fixing. We are deliberately not claiming it costs you revenue: we have no measurement tying missing product markup to lost sales, and neither does anyone else we can find. Fix it because it makes your page machine-readable, not because someone quantified the leak.
Shopify and ProductGroup: the variant schema problem
Shopify stores add a complication: variant products (a shoe in 10 sizes and 4 colours) emit `@type: ProductGroup` rather than `@type: Product`. ProductGroup is a Schema.org type introduced to handle this pattern — the group has name, brand, and offers, and each variant is nested under `hasVariant`.
This is correct Schema.org. But an AI agent — or an audit tool — checking for `@type: Product` will find nothing and score the page as missing product schema. Hidden Layer's product audit now accepts ProductGroup, IndividualProduct, and Product as valid types. But many third-party AI tools don't. If your Shopify store has been flagged as 'missing structured data' by SEO tools, check whether they're checking for ProductGroup.
// Valid Shopify product page schema (simplified)
{
"@context": "https://schema.org",
"@type": "ProductGroup",
"name": "Allbirds Men's Tree Runners",
"brand": { "@type": "Brand", "name": "Allbirds" },
"image": "https://cdn.allbirds.com/image/upload/...",
"description": "Lightweight running shoes made from eucalyptus tree fiber.",
"offers": {
"@type": "AggregateOffer",
"priceCurrency": "USD",
"lowPrice": "110",
"highPrice": "145",
"availability": "https://schema.org/InStock"
},
"hasVariant": [
{
"@type": "Product",
"name": "Allbirds Men's Tree Runners — Size 10",
"sku": "M_TR_10_NGMW",
"offers": { "@type": "Offer", "price": "110", "priceCurrency": "USD" }
}
// ...103 more variants
]
}The five signals that determine your product schema score
Hidden Layer scores product pages against eight checks. The five most commonly missing:
| Signal | Points | Why it matters |
|---|---|---|
| Product/ProductGroup schema present | 10 | Primary signal — without this, nothing else counts |
| offers with price + availability | 8 | AI agents need current price to recommend or compare |
| aggregateRating present | 6 | Trust signal — models weight review scores in recommendations |
| image URL present | 4 | Visual context for multimodal models and shopping interfaces |
| brand present | 3 | Attribution — links product to brand entity in training data |
Schema completeness matters beyond the audit score. When a model synthesises a product recommendation, it tends to name products it has complete, consistent information about. A product with name, price, brand, and reviews in structured data is more likely to be cited accurately than one where the model had to infer from free-form text.
Discovery: can AI agents even find your product pages?
Structured data on product pages is only half the problem. AI agents also need to discover which pages are product pages in the first place. The primary mechanism is your sitemap.xml.
Shopify stores typically expose `/sitemap.xml` which links to sub-sitemaps by type: `/sitemap_products_1.xml`, `/sitemap_pages_1.xml`, etc. An agent that correctly fans out from the root sitemap will find all product URLs. But many Shopify themes use custom sitemap generators or disable the built-in sitemap entirely — leaving AI agents unable to discover the product catalogue without scraping navigation links.
The concrete test: fetch your sitemap.xml and count the product URLs. If that number is zero or suspiciously low, check your Shopify sitemap settings and whether your theme overrides the default.
The bot access problem: WAF rules that block AI shopping agents
The second common failure mode is WAF rules. Cloudflare's Bot Fight Mode, enabled by default on many Shopify stores, blocks requests from non-browser user agents. AI shopping agents that browse product pages to extract information — OAI-SearchBot, Claude-User, PerplexityBot — arrive with non-browser UAs and get 403 responses.
A 403 on a product page doesn't just fail the request — it means the product catalogue is invisible to that AI system for all future requests until the block is lifted. Cloudflare's dashboard has a 'Verified Bots' policy that explicitly allows listed AI crawlers through WAF. Enabling it takes two minutes and restores access for every crawler on the list.
Quick checklist: product AI-readiness in 30 minutes
- Fetch a product URL with curl: `curl -s https://yourdomain.com/products/your-product | grep "application/ld+json"`. If nothing returns, your product schema is missing or injected by JavaScript after load.
- Check the schema type: grep for `"@type": "Product"` or `"@type": "ProductGroup"`. Both are valid. If you see `ProductGroup`, verify it has at least name, offers, and image at the group level.
- Verify offers completeness: `price`, `priceCurrency`, and `availability` should all be present. Missing availability is the most common gap in commerce schema.
- Check your sitemap: `curl -s https://yourdomain.com/sitemap.xml | grep sitemap`. Count how many product sub-sitemaps are listed. Zero means AI agents can't discover your catalogue.
- Check your Cloudflare WAF: Dashboard → Security → Bots → Bot Fight Mode → configure verified bots policy to allow AI crawlers.
- Run a Hidden Layer audit: the product_pages category in the result shows per-page schema completeness and discovery status.
Product schema has been best practice for SEO since 2012, and it remains the cheapest way to make a product page legible to a machine. But legible is not the same as listed. The stores that show up in AI shopping guides are the ones whose products are in the feed, with identifiers that match — and whose pages then read cleanly when an agent does fetch them. Do the feed first. Do the schema because a page that a machine can parse is worth having regardless of which surface is asking.
Footnotes3