How to Add Product Schema with Reviews to a Shopify Product Page

Why Product Schema with Reviews Is Worth Getting Right

Product schema tells search engines and AI tools exactly what a page is about: the product name, price, availability, brand, and more. Add AggregateRating or individual Review markup on top of that, and you give those systems a structured, machine-readable summary of what real customers think. That combination is what drives star ratings in Google search results, and increasingly, it is what helps AI engines like ChatGPT, Perplexity, and Gemini pick your product page as a trustworthy source when someone asks for a recommendation.

Shopify does inject some default structured data on product pages, but it has real gaps. The built-in schema often omits review data entirely, uses incomplete property sets, and does not always reflect your actual app-generated review content. If you want the full picture, you will need to add your own JSON-LD.

Understanding the Schema Types You Need

Product

The Product type from Schema.org is the foundation. At minimum, a useful Product schema block should include:

• name - the product title
• image - at least one image URL
• description - a clear, factual description
• sku - the product SKU
• brand - using a nested Brand type with a name property
• offers - using the Offer type to specify price, currency, and availability

Missing any of these is not fatal, but it reduces how confidently a search engine or AI can interpret the page. The offers block in particular is what populates price and availability in rich results.

AggregateRating

This is the property that produces star ratings in Google. It nests inside your Product block and uses three key properties: ratingValue (the average score), reviewCount (total number of reviews), and bestRating (usually 5). You can also include worstRating (usually 1). Google will not show stars unless this data is present and valid.

Review

Individual Review items can also nest inside a Product block. Each one should have a reviewRating (with its own ratingValue), an author (using Person with a name), and a reviewBody. You do not need to include every single review in the schema, but having two or three well-formed ones alongside an AggregateRating block gives AI engines more substance to work with when evaluating product quality signals.

Building the JSON-LD Block

Here is a practical example of what a complete Product schema block with reviews looks like. This is the format you want to inject into your Shopify product pages:

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Merino Wool Running Socks",
  "image": [
    "https://yourstore.com/products/merino-socks.jpg"
  ],
  "description": "Lightweight merino wool running socks with arch support and moisture-wicking finish.",
  "sku": "MWRS-001",
  "brand": {
    "@type": "Brand",
    "name": "YourBrand"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://yourstore.com/products/merino-wool-running-socks",
    "priceCurrency": "GBP",
    "price": "14.99",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "127",
    "bestRating": "5",
    "worstRating": "1"
  },
  "review": [
    {
      "@type": "Review",
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5",
        "bestRating": "5"
      },
      "author": {
        "@type": "Person",
        "name": "Sarah T."
      },
      "reviewBody": "These are the best running socks I have ever owned. No blisters after a half marathon."
    },
    {
      "@type": "Review",
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "4",
        "bestRating": "5"
      },
      "author": {
        "@type": "Person",
        "name": "James R."
      },
      "reviewBody": "Great quality and comfortable, though sizing runs slightly small."
    }
  ]
}
</script>

Keep the values accurate. Do not fabricate reviews or inflate the ratingValue. Google and AI engines cross-reference structured data against visible page content, and mismatches are a fast route to a manual penalty or being ignored as a source.

Three Ways to Add This to Shopify

Option 1: Edit the theme directly

The most direct method is adding the JSON-LD block to your product.liquid or product.json template file. In Shopify's theme editor, go to Edit Code, find your product template, and paste the script block inside the <head> section or just before the closing </body> tag. To make it dynamic, use Shopify's Liquid variables rather than hardcoded values:

"name": "{{ product.title | escape }}",
"price": "{{ product.price | money_without_currency }}",
"sku": "{{ product.selected_or_first_available_variant.sku }}"

The catch is that review data lives in a third-party app (Judge.me, Okendo, Yotpo, etc.), and those apps do not always expose their data as Liquid variables in a way you can cleanly access. You may be able to pull aggregate rating data if the app adds metafields, but it takes some digging.

If editing theme code is not something you want to risk, there is a cleaner approach covered in this guide on adding JSON-LD schema to Shopify without touching theme code.

Option 2: Use a schema app

Several Shopify apps handle structured data injection. Some are better than others at including review data. The important thing to check is whether the app actually pulls from your review platform, or just injects a generic Product block with no aggregateRating. A static schema block that never updates the review count is worse than useless: it will be wrong within days of installation.

For a detailed breakdown of which apps actually do this well, this post on Shopify schema apps and AI visibility is worth reading before you install anything.

Option 3: Use a service that handles it properly

For stores with large catalogues, or where getting this right really matters commercially, having someone implement and maintain accurate schema is usually the most sensible route. At FlinnSchema, we implement Product schema including dynamic review data as part of our AI visibility service, and we make sure the markup stays accurate as your review counts change.

Common Mistakes That Break Rich Results

Hardcoded review counts

If you paste a JSON-LD block with "reviewCount": "12" and your store collects 40 more reviews over the next month, your structured data is now inaccurate. Google's quality guidelines specifically flag static review data that does not match the visible page. Either use dynamic variables, connect to your review app's API, or update the markup regularly.

Missing or incorrect offer data

The offers block must include priceCurrency and price at minimum. Availability values must use the full Schema.org URL format: https://schema.org/InStock not just the word "InStock". A lot of handwritten schema gets this wrong.

Duplicate schema conflicts

Shopify's default theme already injects a Product schema block. If you add your own, you may end up with two Product blocks on the same page. Google will often try to merge them, but the results are unpredictable. You should either remove the default Shopify schema or modify it in place rather than adding a second block alongside it. Check what is already on the page using Schema.org's validator before you add anything new.

Errors in your markup can also have knock-on effects beyond just missing rich results. This article on what happens when schema markup contains errors covers the risks in more detail.

Reviews not visible on the page

Google's guidelines require that any review data in your schema is also visible to users on the page. You cannot include five reviews in your JSON-LD if only an aggregate star rating widget is shown. If you are marking up individual reviews, they need to be rendered on the page in a form a user (and a crawler) can actually see.

What This Does for AI Search Visibility

Beyond Google rich results, well-structured Product schema with reviews plays a genuine role in how AI search engines evaluate your pages. When Perplexity or ChatGPT is deciding whether to cite your product page as a recommendation, having a clear, machine-readable signal that says "this product has 127 reviews averaging 4.8 out of 5" is a meaningful trust signal. It is the kind of specific, verifiable data that AI systems prefer over vague marketing copy.

Stores that have invested in accurate, maintained schema markup consistently outperform those relying on default Shopify output when it comes to appearing in AI-generated product recommendations. The gap is only going to widen as more consumers start searches in ChatGPT, Perplexity, and Gemini rather than Google.

If you are not sure whether your current setup is working, a free AI visibility audit from FlinnSchema will show you exactly what is missing and what it is costing you in terms of visibility.

Frequently Asked Questions

Does Shopify automatically add review schema to product pages?

No. Shopify's default structured data includes a basic Product block, but it does not include AggregateRating or Review markup. That data comes from third-party review apps, and those apps vary significantly in how well they inject schema. Many inject no review schema at all, or only add it if you enable a specific setting.

Which review apps for Shopify include schema markup automatically?

Judge.me is one of the more reliable options and does inject AggregateRating schema by default. Yotpo and Okendo also offer schema injection, but the quality and completeness varies by plan and configuration. Always check what is actually being output on your live pages using a schema validator, not just what the app claims to do.

Will adding review schema to my product pages immediately show stars in Google?

Not immediately. Google needs to crawl and re-index the page after you add the markup. This typically takes anywhere from a few days to a few weeks depending on how frequently your site is crawled. Once indexed, star ratings can appear in search results, but Google reserves the right not to show them if the markup does not meet its quality standards.

Can I add Product schema with reviews to Shopify without a developer?

Yes, though it depends on your approach. Some apps handle it with no code required. If you want to edit the theme directly, a basic comfort level with Liquid templating helps, but it is not essential for adding a static JSON-LD block. The harder part is making the review data dynamic so it stays accurate over time. That is where most non-technical implementations fall short.