Home › Blog › AggregateRating on Shopify: which review apps inject it correctly

AggregateRating on Shopify: which review apps inject it correctly and which silently break it

9 in 10 Shopify stores in our launch scan fail this signal — and almost every one of them has a reviews app installed, with visible stars on every product detail page. The on-page stars and the schema-readable stars are two different things, and AI shopping agents only read the second one. This guide is the per-app anatomy: what Judge.me, Yotpo, Loox, Stamped, and Okendo inject by default, where each rich-snippets toggle lives, the HTML-source-vs-JSON-LD diff that decides whether your reviews count, and a 30-day playbook for verifying the fix actually landed.

Published 2026-05-01 · ~12 min read · By the CatalogScan team

The two kinds of stars on every Shopify PDP

Open any Shopify product page that has a reviews widget. You'll see something like “★★★★★ 4.7 (3,284 reviews).” Those stars are pixels — DOM elements, often SVGs or background images, rendered by JavaScript that your reviews app injected into the page. They're for humans.

There's a second set of stars on the same page that you can't see. They live inside a <script type="application/ld+json"> tag, written as JSON, structured according to schema.org/AggregateRating. This is what ChatGPT Shopping's crawler, Perplexity's PerplexityBot, Google's Googlebot, and every AI shopping agent we've inspected actually reads when they want to know whether your product has reviews.

The two are completely independent. A reviews widget can show 3,284 reviews on the page while your JSON-LD says nothing at all. We've scanned hundreds of stores; this is the rule, not the exception.

Why? Almost every reviews app ships with a setting called something like “rich snippets,” “schema markup,” or “SEO,” and almost every one of them ships it off by default. Some of them gate the toggle behind a higher plan tier. Some of them have it on by default but inject the schema as a separate floating block instead of slotting it into your existing Product JSON-LD, which strict parsers reject. The result is the same: visible stars, invisible reviews.

The investigation in this post is which apps fail in which way, and what to actually click in each one to fix it. If you'd rather read the per-signal reference first, we keep the canonical AggregateRating signal page updated with the toggle table for every major reviews app.

Why AggregateRating is the tie-breaker signal AI agents use

Of the 15 signals CatalogScan scores, AggregateRating is the highest-failing — but it's also one of the highest-leverage in the 60–80 score band where most stores live. Here's why:

Confidence weighting. When an AI shopping agent answers “what's the best running shoe for flat feet?”, it has dozens of products that clear the floor signals (Product JSON-LD present, GTIN populated, structured Offers). It has to rank them. AggregateRating is the first sortable input it gets after price and availability — a 4.7-star, 3,200-review product carries materially more confidence than a 4.9-star, 12-review one. But agents can only weight what they can read; no AggregateRating in JSON-LD means your product is invisible to that ranking.

Review-count thresholds. Some agent query types have minimum review counts. “Best”-style queries filter more aggressively than “where to buy” queries, but the trigger is consistent: if your reviewCount isn't in the JSON-LD, the filter treats your product as having zero reviews, even if your widget shows 3,284. We've seen this with our own scan-driven tests against ChatGPT Shopping: products with the AggregateRating off entirely consistently lose to lower-rated, lower-reviewed competitors that have it on.

Rich-card rendering. When ChatGPT Shopping or Perplexity Shopping cite your product, the star line in the rich card is rendered from ratingValue in your JSON-LD. Missing the field means the star line disappears from the card. The card looks weaker. Click-through drops.

Stack those three effects and AggregateRating ends up doing more ranking work than its 10-out-of-70 signal weight suggests. The signal weight is what we score; the downstream effect on agent ranking is roughly “you exist or you don't” in the 60–80 band where the marginal product is decided.

What we found scanning 100 top DTC stores

We ran the CatalogScan free scan against the top 100 DTC Shopify stores by traffic the week before launch. AggregateRating's failure rate was the highest of any signal we tested:

The 78% number is the interesting one. These are stores doing $1M to $50M+ a year, almost all with paid teams running their site, with a reviews app installed and paid for. The cost of the fix is one toggle, no developer required. The cost of doing nothing is being invisible to the review-weighted slice of every AI agent's ranking model.

Reviews-app market share in our 100-store sample tracks roughly to industry surveys: Judge.me about 28%, Yotpo about 22%, Loox about 19%, Stamped about 11%, Okendo about 8%, and a long tail of Reviews.io, Trustpilot embeds, Shopify's deprecated Product Reviews app, and custom Liquid setups making up the rest. Those five apps cover >95% of Shopify reviews installs we encounter, which is why this guide focuses on them.

The HTML-source-vs-JSON-LD diff anatomy

To know which failure mode you're in, you have to read both layers of the page. The page-rendered stars and the JSON-LD stars usually disagree in one of four shapes:

<!-- visible widget -->
<div class="jdgm-prev-badge"
     data-average-rating="4.78"
     data-number-of-reviews="3284">
  ★★★★★ 4.78 (3,284)
</div>

<!-- JSON-LD on the page -->
{
  "@type": "Product",
  "name": "Wool Runner",
  "offers": {...}
  /* no aggregateRating field */
}

<!-- separate JSON-LD block -->
{
  "@context": "https://schema.org",
  "@type": "AggregateRating",
  "ratingValue": "4.78",
  "reviewCount": "3284"
}

<!-- Product JSON-LD elsewhere -->
{
  "@type": "Product",
  "name": "Wool Runner"
  /* no aggregateRating field */
}

<!-- inside the Product -->
"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "4.78",
  "reviewCount": "3284 reviews"
}

<!-- inside the Product -->
"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "4.78",
  "reviewCount": "3284",
  "bestRating": "5",
  "worstRating": "1"
}

To know which shape you're in: open any product page on your store, view source, search for aggregateRating case-sensitive. If you find it inside a <script type="application/ld+json"> block whose @type is Product, with both ratingValue and reviewCount set to numeric values, you're Shape D — done. Anything else is one of A, B, or C.

Per-app investigation: where the toggle is, what gets injected, what to watch out for

Here's the toggle path for each of the five reviews apps that cover >95% of Shopify stores. We've tested each one against a fresh demo store; the path notes are current as of the date on this post.

The correct shape, written out

If you're hand-injecting schema (because you're on a Yotpo plan that doesn't support it, because you've removed your reviews app's theme include, or because you'd rather not depend on the app's injection at all), this is the exact shape AI agents want to see, embedded inside your Product JSON-LD:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Wool Runner",
  "sku": "WR-NAVY-10",
  "brand": { "@type": "Brand", "name": "Allbirds" },
  "offers": { "@type": "Offer", "price": "110.00", "priceCurrency": "USD",
              "availability": "https://schema.org/InStock" },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.78",
    "reviewCount": "3284",
    "bestRating": "5",
    "worstRating": "1"
  }
}

Four rules that separate Shape D from the other three:

1. aggregateRating must be a property of a Product, not a free-floating block.
2. ratingValue must be numeric — “4.78” or 4.78, not “4.78 stars”.
3. reviewCount must be an integer — “3284” or 3284, not “3,284” (comma trips strict parsers) or “3284 reviews”.
4. Set bestRating and worstRating explicitly. AI agents are stricter than Google's Rich Results Test about defaulting to 1–5.

If your store sells across multiple regions with different reviewers per region, you have a separate question to answer: do you aggregate globally or per-region? AI agents currently assume global. The schema doesn't have a clean way to express region-scoped reviews; if your French customers leave systematically lower ratings than your US customers, the global aggregate hides that. We don't have a great answer here — most stores aggregate globally and it's fine; some bigger stores split into separate Shopify shops per region and aggregate per shop.

How to fix, in cost order

$0 — flip the toggle in your reviews app (10 minutes)

This is the fix for ~80% of failing stores. Find your app in the table above, click through to the toggle, save. Verify within 5 minutes by viewing source on any PDP and grepping for aggregateRating. If it's there, you're done — no theme edit, no developer.

$0 — hand-inject in main-product.liquid (15–30 minutes)

If your reviews app doesn't expose a toggle (Yotpo free, Trustpilot embed) or you'd rather not depend on the app's injection, you can inline the AggregateRating into your theme's existing Product JSON-LD. The pattern is:

{% raw %}{%- if product.metafields.judgeme.badge -%}
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Product",
    "name": {{ product.title | json }},
    "sku": {{ product.selected_or_first_available_variant.sku | json }},
    {%- assign jm = product.metafields.judgeme.badge | parse_json -%}
    "aggregateRating": {
      "@type": "AggregateRating",
      "ratingValue": {{ jm.value | json }},
      "reviewCount": {{ jm.count | json }},
      "bestRating": "5",
      "worstRating": "1"
    }
  }
  </script>
{%- endif -%}{% endraw %}

The metafield names differ per app — Judge.me uses judgeme.badge, Yotpo uses yotpo.reviews_average + yotpo.reviews_count, Loox uses loox.avg_rating + loox.num_reviews. Each app's docs list the exact metafield path. The general pattern is the same: pull rating + count from the app's metafield, slot into the AggregateRating node, embed inside Product.

$0–$25/mo — install a structured-data app

Apps like Smart SEO, SearchPie, or JSON-LD for SEO will write the Product schema for you and include AggregateRating from your reviews app's metafields. Useful if you want one place to manage all your structured data and you're already paying for one of these for other reasons. Avoid if you can fix it with the toggle — fewer moving parts is better.

$49/mo — CatalogScan Pro

CatalogScan Pro reads your live reviews data via Shopify Admin API metafields and patches the AggregateRating node into your Product JSON-LD without touching theme code. Useful if you're on a custom theme with multiple sources of truth or if you want server-side schema injection that survives theme upgrades. See Pro pricing.

Five mistakes we keep finding

The 30-day verification playbook

Flipping the toggle is the easy part. Verifying that the fix actually rendered, persisted across theme republishes, and is being read by AI agents takes 30 days. Here's the playbook we use on Pro stores:

None of these checks individually proves your AI-agent visibility went up — that takes weeks of search-trend data we don't reliably have on a per-store basis yet. But they do prove the schema is correct, persistent, and parseable, which is the necessary condition for the agent's ranking model to see your reviews at all.