Why AI shopping answers are a different beast to Google Shopping
Google Shopping pulls product data from a structured feed you submit via Merchant Centre. AI engines like ChatGPT, Perplexity, and Gemini do not work that way at all. They read your web pages, draw meaning from the structured data embedded in your HTML, and then decide whether your product is worth mentioning when someone asks a shopping question.
That shift matters a great deal for e-commerce brands. If your product pages have no machine-readable signals, an AI engine has to guess at what you sell, what it costs, whether it is in stock, and whether it is trustworthy. Guess what it usually does when it cannot be sure? It cites a competitor who has made things clearer.
Product schema, implemented correctly as JSON-LD, solves that problem. It gives AI crawlers a precise, structured summary of everything they need to confidently reference your product in a response. This guide walks through exactly how to do it.
The core properties that actually move the needle
There are dozens of properties available under the Product type on Schema.org. Most of them are optional noise. A handful genuinely influence whether an AI engine cites you. Focus here first.
name and description
These seem obvious, but most shops get them wrong. The name should match your page's H1 exactly. If your H1 says "Merino Wool Running Socks - Men's, Ankle Length" then your schema name should say the same thing. Inconsistency between page content and schema is a red flag for both AI parsers and Google's structured data validator.
The description property is where most brands leave serious value on the table. Do not copy-paste a one-line marketing tagline. Write two to four sentences that describe what the product is, who it is for, and what makes it different. AI engines use this field heavily when constructing product summaries in responses. Treat it like a pitch to a very literal-minded journalist.
offers
Without an Offer nested inside your Product schema, you are essentially telling AI engines "this is a product, but I won't tell you what it costs or whether anyone can buy it." That is not enough for a shopping answer. At minimum include:
price- the current selling price as a number, not a string with a currency symbolpriceCurrency- ISO 4217 code, e.g. "GBP" or "USD"availability- use a Schema.org URL likehttps://schema.org/InStockurl- the canonical URL of the product pagepriceValidUntil- a future date in YYYY-MM-DD format; Google and AI parsers treat offers without this as potentially stale
If you run sales or have multiple variants at different price points, use an AggregateOffer with lowPrice and highPrice instead of a single Offer. This is particularly relevant for Shopify stores that surface colour or size variants on the same URL.
aggregateRating
This one is worth its own section. AI engines treat reviews as a trust signal, much like a human reader would. An aggregateRating with a solid ratingValue (say, 4.3 out of 5) and a credible reviewCount (anything above 20 starts to carry real weight) tells an AI that real people have bought and evaluated this product. Without it, your product competes on description alone.
Do not fabricate ratings. AI engines cross-reference signals, and if your schema claims 4.9 stars from 200 reviews but your page shows nothing of the sort, that inconsistency actively damages trust. Only mark up ratings that are genuinely displayed on the page.
brand and image
brand should point to an Organization or Brand entity with a name property. This helps AI engines connect your product to a known brand entity, which is especially useful if your brand appears elsewhere online. image should be an absolute URL to your primary product image. Some AI interfaces (like Perplexity) surface images alongside product citations, so use your best quality shot.
A working JSON-LD example you can adapt
Here is a clean, complete Product schema block. This is the structure FlinnSchema typically implements for e-commerce clients as a baseline before layering on additional properties.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Merino Wool Running Socks - Men's, Ankle Length",
"description": "Lightweight merino wool ankle socks designed for long-distance running. Temperature-regulating, blister-resistant, and machine washable. Available in sizes UK 6 - 12.",
"sku": "MWS-ANKLE-M",
"brand": {
"@type": "Brand",
"name": "TrailReady"
},
"image": "https://www.example.com/images/merino-ankle-sock-main.jpg",
"offers": {
"@type": "Offer",
"url": "https://www.example.com/products/merino-ankle-socks-mens",
"priceCurrency": "GBP",
"price": "18.99",
"priceValidUntil": "2025-12-31",
"itemCondition": "https://schema.org/NewCondition",
"availability": "https://schema.org/InStock",
"seller": {
"@type": "Organization",
"name": "TrailReady"
}
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "134"
}
}
</script>Drop this into the <head> or just before the closing </body> tag. Both positions are valid. Avoid placing it inside a <noscript> block, as some CMS plugins do this incorrectly and it renders the schema invisible to crawlers.
Shopify and WordPress specifics
Shopify
Shopify auto-generates some Product schema through its product.json-ld snippet in most themes. The problem is that the default output is often incomplete: it frequently omits priceValidUntil, uses relative image URLs in older themes, and skips aggregateRating entirely unless you have a reviews app that injects it.
The cleanest fix is to edit your theme's product.liquid or product-template.liquid file and either replace the default schema output or suppress it and add your own <script type="application/ld+json"> block using Liquid variables. Use {{ product.title | json }}, {{ variant.price | money_without_currency }}, and {{ product.featured_image | img_url: 'master' | prepend: 'https:' }} to pull real data dynamically.
WordPress with WooCommerce
If you are using Yoast or Rank Math, be aware that their Product schema output for WooCommerce pages can conflict with schema added by your theme or a dedicated schema plugin. The result is duplicate or contradictory markup that confuses validators and, more importantly, confuses AI parsers. Handling duplicate schema in WordPress is a common problem worth tackling before you add anything new.
The most reliable approach on WooCommerce is to disable schema output in your SEO plugin for product pages and implement a single, controlled JSON-LD block through a custom plugin or a wp_head action hook. That way you know exactly what is being output and can keep it accurate as prices and stock levels change.
Keeping schema accurate at scale
One accurate product page is easy. Five hundred is not. The biggest risk with Product schema at scale is staleness: prices change, products go out of stock, and promotions end. If your schema says a product is £29.99 and InStock but it is actually £39.99 and backordered, AI engines that cross-reference that data will either distrust your markup entirely or surface misleading information to users.
A few practical ways to manage this:
- Generate schema dynamically: Never hard-code prices or availability into static template files. Always pull from your CMS or database at render time.
- Set
priceValidUntilconservatively: If you are not sure, set it three months out and build a reminder to refresh it. Expired validity dates are treated as stale offers. - Validate regularly: Use Google's Rich Results Test or Schema.org's validator on a sample of pages monthly. AI crawlers re-index frequently, so catching errors quickly matters.
- Automate checks for out-of-stock: If a product goes out of stock, the schema must update to
https://schema.org/OutOfStock. A product listed as InStock that returns a 404 or shows "sold out" on the page is an immediate credibility problem.
At FlinnSchema, we typically set up automated schema audits as part of our automations and implementation service so that clients are not manually checking hundreds of product pages every month. The schema feeds from live product data, which means it is always current.
Additional properties worth adding once the basics are solid
Once your core Product schema is clean and validated, a few additional properties can further improve your citation rate in AI shopping answers.
gtin / mpn: Global Trade Item Numbers (barcodes) and Manufacturer Part Numbers help AI engines match your product to known product entities in their training data and knowledge graphs. If you sell branded goods, include the GTIN. If you manufacture your own, include the MPN.
category: A plain-text product category (e.g. "Running Accessories") helps AI engines place your product in context when answering categorical questions like "what are the best running accessories under £20?"
review: Individual Review entities nested alongside aggregateRating add further depth. Include two or three representative reviews with author, reviewRating, and reviewBody. AI engines sometimes quote review text directly in responses, so choose reviews that are descriptive and specific.
hasMerchantReturnPolicy: This newer property allows you to describe your returns policy in structured data. As AI shopping answers mature, trust signals like return windows and conditions will likely play a bigger role in which products get recommended.
How AI engines actually use this data
It is worth being clear about the mechanism here. AI engines like Perplexity crawl pages much like Googlebot does. When they encounter a application/ld+json block, they parse it and store structured attributes alongside the page content in their index. When a user asks "what are good merino running socks under £25 in the UK?", the engine can now match your product by price, type, and availability with far greater confidence than if it had only read your page copy.
ChatGPT's browsing mode and Perplexity's product answer panels both show a clear preference for products where the structured data and page content are consistent and complete. A page that says one thing in its copy and something different in its schema is a page that gets skipped.
If you want a clear picture of whether AI crawlers are currently reaching your product pages at all, the first step is to check which AI crawlers are visiting your site using your server logs. Many brands discover that GPTBot or PerplexityBot is being blocked entirely, which makes all of this schema work pointless until access is restored.
If you are unsure where to start with your own site, a free AI visibility audit will surface exactly which pages are missing schema, which have errors, and which are currently invisible to AI engines. It takes about two minutes to request and gives you a concrete list of fixes rather than vague advice.
Frequently Asked Questions
Does Product schema work the same way on Shopify and WooCommerce?
The JSON-LD structure itself is identical across platforms. The difference is in how you implement it. Shopify uses Liquid templating, so you pull product data using Liquid variables inside your schema block. WooCommerce uses PHP and WordPress hooks. Both approaches generate the same output in the rendered HTML, which is what AI crawlers read. The main risk on both platforms is duplicate schema from built-in theme output clashing with plugin-generated schema.
Will adding Product schema guarantee my product appears in AI answers?
No, and anyone who tells you otherwise is overpromising. Schema markup makes your product eligible for citation by giving AI engines the structured signals they need to reference you confidently. Whether you get cited also depends on the quality and relevance of your product, your domain's credibility, how many competitors are also well-marked-up, and the specific query being asked. Schema is a necessary condition, not a sufficient one.
How often should I update my Product schema?
Ideally, your schema updates automatically whenever your product data changes: price, stock level, promotional period. If that is not technically feasible right now, do a manual audit at least once a month. Pay particular attention to priceValidUntil dates and availability values. Stale or inaccurate schema is worse than no schema in some contexts because it actively misleads AI engines that have cached your data.
Should I add Product schema to category pages as well as individual product pages?
Category pages are better served by ItemList schema, which lets you mark up a list of products with links to each individual product page. This is different from Product schema, which belongs on a single product's page. Using Product schema on a category page that lists 40 items is technically incorrect and will likely cause validation errors. Use ItemList for categories and Product (or ProductGroup for variants) for individual product pages.