How to Get Star Ratings in Google for Your Shopify Store

You've installed a review app. You've collected 50+ reviews with a 4.7-star average. You search for your product on Google — and there are no star ratings in the search results. Meanwhile, your competitor's listing shows gold stars and a review count right in the snippet. They get the click. You don't.

This is one of the most frustrating problems we see at StoreAudit, and it's more common than you'd expect. In our data from 1,200+ store audits, 43% of stores that have a review app installed are not outputting valid review schema markup. The app is collecting reviews and displaying them on the product page, but the structured data that tells Google about those reviews is missing, malformed, or invalid.

The result: Google has no idea your products have reviews. You're missing out on rich results (the star ratings in search listings) that increase click-through rates by 20-35% according to multiple studies. This guide explains how review schema works, why it breaks, and how to fix it for every major Shopify review app.

What Is Review Schema and Why Does It Matter?

Schema markup (also called structured data) is a standardized format for providing information about a page to search engines. It's invisible to visitors — it lives in your page's HTML code, not the visible content. When Google crawls your product page, it reads this structured data to understand details like the product name, price, availability, and reviews.

Review schema specifically uses the AggregateRating type within a Product schema object. It tells Google: “This product has X reviews with an average rating of Y out of 5 stars.” When Google validates this data and decides to display it, your search listing gets star ratings — the gold stars and review count that appear below the page title in search results.

These rich results are one of the highest-impact SEO features available to e-commerce stores. They don't affect your ranking position directly, but they dramatically affect whether someone clicks your listing versus a competitor's. A listing with 4.7 stars and 127 reviews next to a listing with no stars? The choice is obvious.

What Valid AggregateRating Schema Looks Like

Here's the structure Google expects inside your Product schema, using JSON-LD format (the format Shopify and most review apps use):

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Classic Leather Bifold Wallet",
  "image": "https://yourstore.com/wallet.jpg",
  "description": "Handmade full-grain leather wallet",
  "brand": {
    "@type": "Brand",
    "name": "Your Brand"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "127",
    "bestRating": "5",
    "worstRating": "1"
  },
  "offers": {
    "@type": "Offer",
    "price": "59.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

The critical fields inside aggregateRating are ratingValue (the average score), reviewCount (the total number of reviews), and bestRating/worstRating (the scale). All four must be present and valid for Google to recognize the data.

How Major Shopify Review Apps Handle Schema

Each review app handles schema differently. Understanding how your specific app works is the first step to diagnosing why your stars might not be showing up.

Judge.me

Judge.me injects JSON-LD schema automatically on product pages. It adds both the AggregateRating and individual Review objects. For most stores, Judge.me's schema works out of the box — it's one of the most reliable apps for structured data.

Common issue: If you also have Shopify's built-in product schema (from your theme), you can end up with duplicate Product schema blocks on the same page — one from the theme (without reviews) and one from Judge.me (with reviews). Google may pick the one without reviews, or flag a conflict. Check for duplicate schema using the Rich Results Test (covered below).

Fix: Judge.me has a setting under “Display > SEO Snippet” where you can choose whether Judge.me injects its own Product schema or adds the aggregateRating to your existing theme schema. If your theme already has Product schema, select the “Append to existing” option to avoid duplication.

Loox

Loox focuses on photo reviews and handles schema through its widget. When the Loox widget is active on a product page, it adds AggregateRating data to the page's schema.

Common issue: Loox's schema injection depends on the widget being present and loaded on the page. If you've customized your theme and the Loox widget isn't rendering (even if reviews show via API), the schema may not be injected. This is the “app installed but schema missing” scenario — reviews appear visually but Google can't see them.

Fix: In your Loox dashboard, go to Settings > SEO and confirm that “Add SEO Rich Snippets” is enabled. If it's enabled but schema still isn't appearing, check whether the Loox widget block is actually present in your theme's product template — sometimes theme updates or template changes remove app blocks without warning.

Stamped.io

Stamped provides schema through both its widget and a separate SEO snippet feature. The SEO snippet is a separate piece of code from the visible review widget.

Common issue: Stamped's SEO snippet must be installed separately from the review widget. Many store owners install the visible widget (star ratings and reviews you can see) but skip the SEO snippet installation (the invisible schema code). The result: reviews display on the page, but no structured data exists for Google to read.

Fix: Follow Stamped's documentation to install the SEO snippet code, which is separate from the main widget. It goes in your theme's product template and adds the JSON-LD schema. After installation, verify with the Rich Results Test.

Yotpo

Yotpo handles schema server-side for stores on their paid plans. The schema is injected based on review data stored on Yotpo's servers, not generated client-side by JavaScript.

Common issue: Yotpo's free plan may not include schema markup — it's a paid feature on some plan tiers. Additionally, Yotpo's schema can conflict with theme-generated Product schema, creating duplicate objects similar to the Judge.me issue described above.

Fix: Check your Yotpo plan to confirm schema is included. If it is, use the Rich Results Test to verify it's appearing correctly. If you have duplicates, you'll need to either disable your theme's built-in Product schema or configure Yotpo to merge its data into the existing schema rather than creating a separate block.

The Three Most Common Schema Problems

1. App Installed but Schema Missing

This is the most common problem: the review app displays reviews on the page, but no structured data is present in the page's source code. We see this in 27% of stores that have review apps installed.

Why it happens: The review widget loads via JavaScript, but the schema markup was never installed, was removed during a theme update, or requires a separate installation step that was skipped. Some apps render reviews client-side (in the browser via JavaScript) but need the schema injected server-side (in the HTML source) to be visible to Google.

How to diagnose: View the page source (Ctrl+U or Cmd+U) and search for "aggregateRating". If you can see reviews on the page but this string doesn't appear in the source code, your schema is missing.

2. Duplicate Product Schema

Your theme outputs one Product JSON-LD block (without reviews), and your review app outputs another Product JSON-LD block (with reviews). Google sees two conflicting Product objects for the same page and may use the one without reviews — or flag both as problematic.

Why it happens: Shopify themes (especially Dawn-based themes) include their own Product structured data in the theme code. Review apps also inject Product structured data to include the aggregateRating. Neither knows about the other, creating duplication.

How to diagnose: In the page source, search for "@type": "Product" or "@type":"Product". If you find it more than once, you have duplicate Product schema. Count the occurrences — there should be exactly one.

How to fix: The cleanest solution is to remove the Product schema from your theme code and let the review app handle it entirely (most review apps output complete Product schema, not just the rating). In your theme, look for the JSON-LD script in product.liquid, main-product.liquid, or a structured-data.liquid snippet file. Comment it out and verify that the review app's schema covers all required Product fields.

Alternatively, configure your review app to append its aggregateRating to the existing theme schema instead of creating a new block. Judge.me and some other apps support this option in their settings.

3. Invalid or Incomplete Schema

The schema exists but contains errors — missing required fields, wrong data types, or invalid values. Google ignores invalid schema entirely, so even a small error means no rich results.

Common errors we find:

• ratingValue is “0” or empty (product has no reviews yet but schema still outputs)
• reviewCount is “0” (same issue — outputting an AggregateRating with zero reviews is invalid)
• ratingValue exceeds bestRating (e.g., ratingValue is “4.7” but bestRating is missing, defaulting to “1”)
• price is missing or “0.00” in the associated Offer schema
• The @context field is missing or misspelled

How to fix: The schema should only output aggregateRating when a product has at least 1 review. Most review apps handle this correctly, but some inject the schema structure with empty values on products with no reviews. If this is happening, check the app's settings for a “minimum reviews for schema” option, or contact the app's support team.

Testing with Google's Rich Results Test

Google's Rich Results Test at search.google.com/test/rich-results is the definitive tool for validating your review schema. Enter a product page URL and Google will show you exactly what structured data it finds, whether it's valid, and what errors exist.

Step-by-Step Validation Process

1. Go to the Rich Results Test and enter a product page URL (pick a product that has reviews).
2. Wait for the test to complete. It renders the page as Google sees it, including JavaScript-generated content.
3. Look for a “Product” result in the detected items. Click on it to expand the details.
4. Verify that aggregateRating appears with the correct ratingValue and reviewCount.
5. Check for any warnings (yellow) or errors (red). Warnings won't prevent rich results but are worth fixing. Errors will prevent rich results entirely.
6. If the Product item shows no aggregateRating, your review schema is not being detected.

Important distinction: The Rich Results Test renders JavaScript, so it will see schema that's injected client-side. However, Google's crawler may not always execute JavaScript when indexing. For maximum reliability, your schema should be in the server-rendered HTML source (view page source), not only injected by JavaScript after page load. This is also a factor when considering your broader Shopify SEO setup.

Also Test with Schema Markup Validator

Google's Schema Markup Validator at validator.schema.org checks the technical validity of your schema against the Schema.org specification. The Rich Results Test checks whether Google can generate a rich result from your data — the Schema Markup Validator checks whether the underlying structure is technically correct. Use both.

Schema for Products Without Reviews

A common question: should you add review schema to products that don't have any reviews yet? The answer is no. Google's guidelines explicitly state that AggregateRating should only be present when there is at least one review. Outputting an aggregateRating with a reviewCount of “0” violates Google's structured data guidelines and can result in a manual action (penalty).

Your Product schema should still be present for products without reviews — it just shouldn't include the aggregateRating property until the first review comes in. Most review apps handle this correctly by conditionally including the rating data only when reviews exist. Verify this by testing a product URL that has no reviews in the Rich Results Test.

How Long Until Stars Appear in Search Results?

After fixing your schema, stars don't appear immediately. Google needs to recrawl and reindex your product pages. This typically takes 1-4 weeks depending on how frequently Google crawls your store.

You can accelerate the process:

1. Request indexing in Google Search Console: Go to Google Search Console, enter the URL of a product page with fixed schema in the URL inspection tool, and click “Request Indexing.” This doesn't guarantee immediate recrawling, but it adds the URL to the priority queue.
2. Submit your sitemap: In Google Search Console, go to Sitemaps and confirm your sitemap (sitemap.xml) is submitted. This helps Google discover all your product pages.
3. Be patient: Even after Google recrawls, it takes time for rich results to appear. Google doesn't guarantee rich results even for pages with perfect schema — it's at Google's discretion. But valid schema is a prerequisite.

You can use the meta tag checker to verify your structured data is present across multiple product pages at once, rather than testing URLs one at a time.

Advanced: Adding Review Schema Manually

If your review app doesn't handle schema correctly and you can't switch apps, you can add review schema manually to your Shopify theme. This requires editing your theme's Liquid code.

In your product template (usually sections/main-product.liquid or templates/product.liquid), locate the existing Product JSON-LD block. Add the aggregateRating property using Liquid to pull data from your review app's metafields or API.

The approach depends on your review app: Most apps store review data in product metafields. Judge.me, for example, stores the rating in product.metafields.judgeme.rating. You can reference these metafields in your Liquid code to build the schema dynamically.

Warning: Manual schema requires maintenance. If you change review apps, the metafield references break. If you edit the schema incorrectly, you could introduce errors that prevent all structured data from being recognized. Only go this route if your app's built-in schema is genuinely broken and the app's support team can't fix it.

Review Schema Checklist

Use this checklist to verify your review schema is working correctly:

• Your review app's SEO/schema setting is enabled.
• Rich Results Test shows a valid Product result with aggregateRating for a product with reviews.
• There is exactly one Product JSON-LD block per product page (no duplicates from theme + app).
• ratingValue matches the actual average rating displayed on the page.
• reviewCount matches the actual number of reviews displayed.
• Products with zero reviews do NOT output aggregateRating.
• The schema includes bestRating (“5”) and worstRating (“1”).
• The schema includes valid offers with price, priceCurrency, and availability.
• Schema Markup Validator shows no errors.
• You've requested reindexing in Google Search Console for your top product pages.

The Competitive Advantage of Getting This Right

Review schema is one of the few SEO improvements where the impact is directly visible in search results. You can literally see the difference — your listing either has stars or it doesn't. And because 43% of Shopify stores with review apps still have broken schema (based on our audit data), getting this right gives you an immediate competitive advantage over nearly half the stores in your niche.

The 20-35% increase in click-through rate from rich results compounds over time. More clicks mean more traffic, which means more reviews, which strengthens your schema data further. It's a flywheel — but only if the technical foundation (valid schema) is in place to start it spinning.

If you've been collecting reviews but not seeing stars in Google, fix this today. The investment is an hour of your time. The return is every Google search click you've been missing.