Product schema and structured data for AI shopping

AI shopping assistants read your catalogue through structured data — Product, Offer, and AggregateRating JSON-LD — not through your theme design. When ChatGPT, Google's AI Overviews, or Perplexity compare products, they extract price, availability, rating, and brand from your schema. If those fields are missing or wrong, you get skipped or misquoted, no matter how good the product is.

I am a senior Shopify developer in Delhi, and I add and audit product schema on nearly every store I build or optimise for AI search. This is the practical version: which fields actually move the needle, how Shopify emits schema out of the box, where the gaps consistently show up, and how to validate the whole thing before you trust it.

What is product schema, and why does AI shopping depend on it?

Product schema is structured data that describes a product in a format machines can parse without guessing. On Shopify it is almost always JSON-LD — a block of JSON in a <script type="application/ld+json"> tag — following the schema.org Product vocabulary.

A human reads your product page and understands "₹2,499, in stock, 4.6 stars." A crawler reading raw HTML sees a jumble of divs and prose and has to infer all of that. Structured data removes the inference. It states, explicitly and in a fixed shape:

• This is a Product named X, by brand Y.
• It has an Offer: price 2499, currency INR, availability InStock.
• It has an AggregateRating: 4.6 out of 5, from 218 reviews.

AI shopping engines are built to consume exactly this. When someone asks ChatGPT "best affordable running shoes under ₹3,000" or asks Perplexity to compare two skincare serums, the assistant is assembling an answer from whatever structured, quotable facts it can find. A product with clean schema is a quotable candidate. A product without it is a paragraph the model has to interpret — riskier, so it often gets dropped in favour of a competitor whose data is unambiguous.

This is the same shift I wrote about in how D2C brands show up in ChatGPT and Perplexity: the winners are not the loudest brands, they are the most legible ones. Product schema is where legibility starts for a store.

Which schema fields actually matter for AI shopping?

Not all fields are equal. Here is what I prioritise, and why, based on what AI shopping surfaces and Google product results actually use.

If you optimise nothing else, get price, currency, availability, brand, and a real aggregateRating correct on every product. Those five are the facts an AI assistant leans on to decide whether to put you in the answer.

A note on gtin and sku: these matter more than people think. Global identifiers let engines connect your product page to the same product on other sources, which builds confidence in your data. If you sell your own branded SKUs without a GTIN, at minimum populate sku and brand consistently so you own the identity.

How does Shopify emit product schema out of the box?

This is where most store owners get a false sense of security. The honest answer: Shopify and your theme emit some product schema, but rarely all of it, and rarely perfectly.

There are two sources of structured data on a typical Shopify store:

1. Your theme. Modern Online Store 2.0 themes — Dawn and most premium themes — include a JSON-LD block on the product template. Dawn, for example, outputs a Product object with name, description, image, offers, and often sku and brand. It builds this from Liquid objects like product, product.selected_or_first_available_variant, and product.metafields.

2. Shopify's own injection. Shopify adds some structured data at the platform level, and apps (reviews, SEO, feed apps) inject more.

The problem is that these sources are inconsistent and uncoordinated. In audits I regularly see:

• Themes that emit Product but omit aggregateRating entirely, because reviews live in an app the theme's schema never reads.
• A single offers object for a product with many variants and prices, so the marked-up price is wrong for most of the catalogue.
• brand hardcoded, missing, or set to the theme vendor instead of the actual brand.
• Duplicate or conflicting JSON-LD blocks — one from the theme, one from an SEO app — that contradict each other on price.
• Invalid JSON that silently fails to parse, so effectively there is no schema despite the block being present.

The takeaway: never assume Shopify has handled schema for you. The theme's intent and the rendered output are different things. You have to look at the actual HTML the crawler receives. If you built on a custom theme, this is exactly the kind of gap I check for — see custom theme vs premium theme for where control over schema fits into that decision.

What does complete Product schema look like?

Here is a clean, complete example for a single-variant product. This is the shape you are validating against.

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Aravali Merino Crew Sweater",
  "description": "100% extra-fine Australian merino wool crew, machine-washable, in five colours.",
  "image": [
    "https://cdn.shopify.com/.../sweater-front.jpg",
    "https://cdn.shopify.com/.../sweater-back.jpg"
  ],
  "brand": { "@type": "Brand", "name": "Aravali" },
  "sku": "ARV-SWT-CRW-NVY",
  "gtin": "08901234567890",
  "offers": {
    "@type": "Offer",
    "url": "https://aravali.example/products/merino-crew",
    "priceCurrency": "INR",
    "price": "3499",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "218"
  }
}

For a product with multiple variants at different prices, offers should be an AggregateOffer with lowPrice, highPrice, priceCurrency, and offerCount — or an array of individual Offer objects. A single flat price on a variant product is one of the most common and most damaging errors, because AI answers will quote a price that is only true for one variant.

The aggregateRating block must be driven by a review app that stores real reviews, and the number must match what a shopper sees on the page. More on that below, because it is where stores get penalised.

The five gaps I find on almost every store

After enough audits, the failures cluster. If you check nothing else, check these five.

1. Missing aggregateRating. Reviews render visually via an app, but the app's rating never makes it into the JSON-LD. Result: no stars in search, and no rating for an AI engine to quote in a comparison. Fixed by wiring the review app's schema output correctly, or injecting aggregateRating from a metafield the app populates.

2. Wrong price on variant products. One Offer with one price on a product that has five variants across a price range. The marked-up price is right for one variant and wrong for the rest, so AI shopping quotes a number your shopper won't see at checkout.

3. Availability that lies. Static InStock that never updates when inventory hits zero. An AI assistant that recommends an out-of-stock product looks bad, so engines quietly de-prioritise sources whose availability drifts.

4. Missing or wrong brand. No brand, or brand set to the theme author. Without a correct brand, an engine can attribute your product to a marketplace reseller undercutting you, and you lose the citation to them.

5. Duplicate, conflicting JSON-LD. The theme emits one block, an SEO app emits another, and they disagree. Validators flag it, and crawlers may trust neither. Pick one source of truth and disable the rest.

Every one of these is fixable in Liquid, in metafields, or in app configuration. None requires replatforming. But you cannot fix what you have not measured, which is why validation is not optional.

On-page schema vs a merchant feed: you need both

A question I get constantly: "I already have a Google Shopping feed — isn't that the same thing?" No. They feed different channels, and complete AI shopping coverage wants both.

On-page schema is what makes your page legible the moment an AI assistant or crawler lands on it. The Merchant feed is what puts you in the structured commerce index that increasingly powers AI shopping answers. They should never disagree — if your feed says ₹3,499 and your JSON-LD says ₹2,999, you have created a trust problem that suppresses you in both channels. Keep price, availability, and identifiers consistent across both, and you cover the full surface.

How do I validate product schema on Shopify?

Validation is the step people skip, and it is the step that actually protects you. Here is the workflow I run on every store.

1. Google Rich Results Test. Paste a live product URL into the Rich Results Test. It shows what Google parses, which rich result types you qualify for, and every error and warning. Fix all errors; treat warnings as a priority list.

2. schema.org Validator. Cross-check with the schema.org Validator for spec-level correctness, independent of Google's specific requirements.

3. View the rendered source. Open the product page, view source, and confirm the JSON-LD is actually present and complete. This catches themes whose schema depends on JavaScript, or blocks that fail to render.

4. Search Console reports. In Google Search Console, watch the Product snippets and Merchant listings reports. These show errors across your whole catalogue, not one URL — which is how you catch the variant-price problem that only shows on some products.

5. Ask the AI directly. The real-world test: ask ChatGPT, Perplexity, and Google's AI about your product and category. Do they quote your price and rating correctly? Do they surface you at all? This is closer to the AEO validation I describe in AEO vs SEO vs GEO — you are testing the answer, not just the markup.

Run this loop after any theme change, app install, or migration, because all three can silently break schema. And if you are still deciding whether schema is worth the effort against everything else on your list, remember it is one of the rare optimisations that improves classic Google rich results and AI shopping legibility from the same implementation.

Where product schema sits in the bigger AEO picture

Schema is foundational, but it is not the whole strategy. It makes your catalogue legible so that when an AI engine has a reason to consider you, your facts are correct and quotable. It does not, on its own, create the demand or authority that makes you a candidate in the first place.

The full stack, in the order I build it:

• Product schema — Product, Offer, AggregateRating on every product. The subject of this post.
• Metafields — structured attributes (materials, dimensions, use-cases) that feed both schema and AI-readable content. See the metafield strategy that makes your store AI-readable.
• Real reviews — genuine, visible, marked-up ratings. Never faked.
• Content and authority — the reasons an engine considers you before it ever reads your schema.

Get the schema right first, because it is the cheapest, highest-leverage fix and it unblocks everything above it. A store with authority but broken schema gets misquoted. A store with clean schema and no authority is legible but ignored. You want both, and schema is the half you fully control.

What's next

If your product pages are not showing up — or showing up with the wrong price and no stars — in AI shopping and Google results, the fastest path is an audit of what your theme and apps are actually emitting versus what should be there. That is standard work on the builds I do as a Shopify developer in Delhi: I check the rendered schema on real product URLs, fix the variant-price and aggregateRating gaps, and validate the whole catalogue in Search Console.

Tell me your store URL and your top three products at /start and I will tell you exactly which fields are missing and what it takes to fix them — no obligation, just an honest read of where your catalogue stands.

Related reads

• The Shopify metafield strategy that makes your store AI-readable — the structured attributes that feed your schema.
• How D2C brands show up in ChatGPT and Perplexity — the AEO strategy schema plugs into.
• AEO vs SEO vs GEO — how answer-engine optimisation differs from classic search.

Sources

• Schema.org — Product type
• Google Search Central — Product structured data
• Google Rich Results Test