AggregateRating Schema

TL;DR — AggregateRating is code you add to a page that says “the average rating of this thing is 4.6 stars, out of this many ratings.” It’s what powers the ⭐ star snippet you see under some search results. Most of the time you nest it inside the markup for whatever’s being rated (a product, a recipe, a business) — Google also allows a standalone version that names the rated item directly, but nesting is the common pattern. And you can’t just rate your own business and expect stars — Google blocks that.

What AggregateRating schema is

When a page shows something like “4.6 ★ (218 ratings)”, a human reads it at a glance. A search engine sees plain text and has to guess what those numbers mean. AggregateRating spells it out in code, using the shared schema.org vocabulary: it labels the average score, how many ratings it’s based on, and the scale.

The key word is aggregate — it’s the average of many ratings. That’s different from Review schemaReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average., which marks up one person’s written opinion. Most pages that have both use them together: one AggregateRating for the overall average, plus a handful of individual Reviews.

It’s almost always written as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. — a small block of code that sits in the page without changing how the page looks.

Why it’s worth doing

The payoff is the star-rating rich snippet: those gold stars and a rating count under a search result. A listing with stars stands out and can earn more clicks. To get it, Google needs a few pieces:

• ratingValue — the average score, like 4.6.
• at least one count — either ratingCount (how many ratings total) or reviewCount (how many people left a review, with or without a star rating). You need one of them.
• itemReviewed — what’s being rated. If you nest AggregateRating inside the product/recipe/etc., this is covered by that nesting and you can skip it — but either way, the thing being rated needs a name. Evidence for this claim Google supports aggregate ratings in review snippets only for eligible item types and qualifying content. Scope: Google Search review snippet requirements; stars are not guaranteed. Confidence: high · Verified: 2026-07-14 Google: Review snippet structured data

Optionally, bestRating and worstRating describe the scale (Google assumes 1–5 if you leave them off).

The thing most people get wrong

You can’t add AggregateRating to your own business and get stars. If you run a local business or a company site and mark up “our customers rate us 4.9 stars,” Google will not show those stars. It calls this self-serving — a business rating itself — and it’s blocked for LocalBusiness and Organization markup specifically.

But — and this is the part that trips everyone up — this is not a blanket “you can’t rate your own stuff” rule. An online shop can legitimately show star ratings on its own product pages. The block is about a business rating itself as a business, not a store showing genuine customer ratings of the products it sells.

Two more beginner traps:

• You always need a count, not just an average. A bare “4.6 stars” with no number of ratings behind it isn’t enough.
• Ratings have to be real. Faking or buying ratings isn’t just against the rules — it can get your page hit with a manual penalty that removes rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show..

Want the exact required properties, the ratingCount vs. reviewCount distinction, the full self-serving-reviews scope, and how to fix the common Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. errors? Switch to the Advanced tab.

TL;DR — AggregateRating is usually nested inside a parent type’s aggregateRating property (Product, LocalBusiness, Recipe, Book, Course, Event, Movie, SoftwareApplication, and others), which is why nested examples omit itemReviewed — but Google’s spec also supports a non-nested AggregateRating that names itemReviewed directly. Either way, the item being rated needs a name. Google’s required properties for the star rich result are ratingValue, at least one of ratingCount/reviewCount, and itemReviewed when not nested; bestRating/worstRating are recommended (essential for non-1–5 scales). The eligibility rule to get exactly right: self-serving ratings are ineligible for the star feature specifically on LocalBusiness/Organization — a business rating itself — while Product, Recipe, Movie, and most other supported types stay eligible for genuine ratings. ratingCount (all ratings, star-only included) and reviewCount (people who left a review, with or without a rating) are different numbers. Valid markup earns star eligibility, not ranking, and fabricated ratings can trigger a structured-data manual action. This topic is cross-listed under structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. and under ecommerce SEOEcommerce SEO is the practice of optimizing an online store so its product and category pages rank in organic search and attract purchase-intent visitors. It uses the same Google algorithm as any other site, but compounds the usual SEO work with commerce-specific challenges like faceted navigation, product variants, and platform-imposed URLs. because ratings markup is a recurring ecommerce audit item.

AggregateRating vs. Review — the distinction everything hinges on

Most competitor guides blur these two types into one flat requirements list. They’re distinct:

• Review marks up one reviewer’s opinion of an item — a single person, a single reviewRating, a body of review text.
• AggregateRating marks up the statistical average of many ratings — ratingValue plus a count.

Many real implementations use both together, nested inside the same parent type: an aggregateRating for the overall score and an array of review objects for individual opinions. Google’s guidance runs one direction, not both: if you’re already marking up multiple individual reviews, add an aggregate rating alongside them. That doesn’t mean an AggregateRating on its own needs invented Review objects to go with it — a page with only an aggregate and no individual reviews is a normal, complete implementation. If you only remember one thing: Review = one opinion, AggregateRating = the average of many. For the single-reviewer side, see the Review schemaReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average. sibling.

Nested vs. non-nested — two valid ways to attach it

AggregateRating has no independent meaning on its own page, but it isn’t strictly “nest it or nothing” either. Google supports two shapes:

• Nested (the common pattern) — AggregateRating sits inside another type’s aggregateRating property (Product, LocalBusiness, Recipe, and the rest of the supported list below). Because the parent type already identifies the item, a nested AggregateRating omits itemReviewed — but the parent item still needs a name.
• Non-nested — AggregateRating can also stand on its own, provided it supplies itemReviewed naming the thing being rated. This is less common in practice but it’s a documented, valid path, not a workaround.

Either shape needs the reviewed item’s name somewhere — on the parent when nested, inside itemReviewed when not. The host types Google supports for the review/star rich result are a finite list: Book, Course, Event, LocalBusiness, Movie, Product, Recipe, Software App, plus additional supported nesting types (CreativeWorkSeason, CreativeWorkSeries, Episode, Game, MediaObject, MusicPlaylist, MusicRecording, and Organization).

The practical consequence: putting aggregateRating on an unsupported type won’t render stars even if the markup validates cleanly. Validation and rich-result eligibility are two different bars.

Required and recommended properties

Google’s spec (stricter than bare schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor.) for the star rich result. The itemReviewed row depends on which shape you’re using:

Two formatting rules from schema.org’s own usage notes that cause avoidable validation failures: use real digit characters (0–9), not look-alike Unicode symbols, and use a period as the decimal separator, not a comma. "4,6" is a common mistake in locales that use comma decimals.

TIP Catch an impossible rating before you publish it

This check keeps the average, scale, and supporting count together so a valid-looking number does not hide an ineligible aggregate.

Build the rating block and fix its field-level errors with my free Schema Markup Generator Free

1. Choose the real parent type and enter the average shown on the page.
2. Add ratingCount or reviewCount using the count users can verify.
3. Keep ratingValue inside the declared bestRating and worstRating scale, then copy the corrected JSON-LD.

Tap to enlarge

The generator reports two issues. The AggregateRating needs ratingCount or reviewCount, and ratingValue 6 cannot exceed bestRating 5. The code preview shows the incomplete aggregateRating nested in a Product.

ratingCount vs. reviewCount — a real distinction

Many guides use these interchangeably, or shrink reviewCount down to just “written reviews.” Google’s current property definitions are more specific:

• ratingCount — the total number of ratings, including star-only submissions with no accompanying review text.
• reviewCount — the number of people who provided a review, with or without an accompanying rating. It isn’t strictly “written reviews only” — it’s keyed to people who reviewed, whether or not they also left a numeric rating.

In practice, on most rating/review platforms these still land as different numbers, because not everyone who leaves a star rating writes a review and not everyone who writes a review attaches a star. A store might show 4.6 stars from a ratingCount of 1,200, where 340 people (reviewCount) actually left review text. Map the definitions above onto however your own platform separates “rated” from “reviewed” rather than assuming the site’s rating/review split matches this example exactly. Google requires at least one of the two properties; supply the one that matches what your platform actually tracks, and don’t inflate either to a number your page can’t support.

bestRating / worstRating — include them off the default scale

Google assumes a 1–5 scale when these are absent. If you rate on 1–10, out of 100, or any non-default range, you must set bestRating/worstRating or Google may misread the scale — a 9.2 on a 10-point scale, left unqualified, gets interpreted as 9.2 out of 5, which is nonsensical.

The self-serving reviews rule — scoped precisely

This is the single most-mangled point in the topic, so I’ll state it exactly.

Google’s wording: “If the entity that’s being reviewed controls the reviews about itself, their pages that use LocalBusiness or any other type of Organization structured data are ineligible for star review feature.” Read the scope carefully — it names LocalBusiness and Organization (and their subtypes). It’s about a business rating itself as a business. Evidence for this claim Google requires ratings represented in structured data to be visible to users and prohibits misleading or fabricated review markup. Scope: Google Search structured-data and review snippet policies; violations can remove feature eligibility. Confidence: high · Verified: 2026-07-14 Google: Review snippet structured data

It does not apply to Product. A webshop can legitimately show star ratings on its own product pages — that’s the average of genuine customer ratings of a product it sells, not the business rating itself. Recipe, Movie, Book, SoftwareApplication, and the rest of the supported list stay eligible too, subject to the ratings being genuine.

This rule dates to a September 2019 Google policy change (“Making Review Rich Results more helpful”), which introduced the “self-serving” framing — including reviews of your own business embedded directly or pulled in via a third-party widget. (I’m paraphrasing the reasoning of that announcement rather than quoting it; the current, citable statement of the rule is the Review snippet documentation quoted above.) The upshot: a third-party review widget on your own LocalBusiness/ Organization page is still self-serving and still ineligible for stars.

Organization is exactly why the Organization schemaOrganization schema (schema.org/Organization) is structured data that describes the business or entity itself — name, logo, official URL, social profiles, contact info, and identifiers — rather than a page's content. Google says it can help disambiguate your brand and some properties can influence visual elements like Knowledge Panel/attribution; it has no required properties and doesn't guarantee a Knowledge Panel. sibling is relevant here — it’s one of the two host types where self-hosted ratings won’t earn stars.

Genuine ratings only — the spam and manual-action policy

Two flat rules from Google’s guidance:

• Don’t aggregate from other sites. Google: “Don’t aggregate reviews or ratings from other websites.” Scraping ratings from elsewhere into your own markup is out.
• Ratings must be from real users. Google’s structured-data policies frame genuine ratings as enforced, not aspirational — its recipe-specific example notes that “reviews or ratings not by actual users may result in manual action.” That principle generalizes to the reviews policy across types.

A structured-data manual action for misleading or fake ratings removes rich-result eligibility for the page. This is enforced, not theoretical. Also make the review content genuinely present on the page — Google expects the marked-up ratings to be readily available to users on the same page, about a specific item, not a category or a list.

Where AggregateRating sits in the wider picture

Like all structured data, AggregateRating affects rich-result eligibility, not ranking — the broader Schema MarkupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and Structured Data hubs make that case in full, so I won’t re-litigate it here. aggregateRating is a recommended property on Product (the most common real-world host) and on ProductGroup for variant-level rating rollups — both natural next reads. Use JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.; it’s Google’s recommended format and the one every example in this article uses.

Bing and other engines: schema.org is a joint Google/Microsoft/Yahoo/Yandex vocabulary, and Bing’s general structured-data documentation confirms it reads schema.org/JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. markup. What isn’t currently verifiable against first-party Microsoft documentation is a type-specific claim of parity with Google’s AggregateRating requirements — Bing publishes no comparable per-type required/recommended breakdown and no self-serving-reviews policy documentation the way Google does, and its rich-result surface for ratings is narrower and less documented. Don’t assume Bing’s eligibility rules mirror Google’s point-for-point; treat this as an open question rather than a confirmed one until Bing publishes its own AggregateRating-specific guidance.

AI summary

A condensed take on the Advanced version:

• What it is: schema.org/AggregateRating markup (usually JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.) for the average of many ratings/reviews of an item — as opposed to Review, which is one reviewer’s opinion. Many pages use both together; Google asks for an aggregate when you’re already marking up multiple individual reviews, not the reverse.
• Nested or non-nested: AggregateRating is usually nested in a parent type’s aggregateRating property (Product, LocalBusiness, Recipe, Book, Course, Event, Movie, SoftwareApplication, and others), which is why nested examples skip itemReviewed — but Google also supports a non-nested AggregateRating that names itemReviewed directly. Either way the rated item needs a name.
• Required for the star rich result: ratingValue, at least one of ratingCount/reviewCount, and itemReviewed when not nested. Recommended: bestRating/worstRating (essential off the default 1–5 scale).
• ratingCount vs. reviewCount: ratingCount = all ratings incl. star-only; reviewCount = people who left a review, with or without a rating. Different numbers; you need one.
• Self-serving rule (the key confusion), scoped precisely: self-serving ratings are ineligible for the star feature only on LocalBusiness/Organization — a business rating itself — introduced Sept 2019. Product, Recipe, Movie, etc. stay eligible for genuine ratings. A third-party widget of your own business reviews is still self-serving.
• Supported host types are finite: Book, Course, Event, LocalBusiness, Movie, Product, Recipe, Software App, plus additional nesting types. On an unsupported type, stars won’t render even if markup validates.
• Genuine ratings only: “Don’t aggregate reviews or ratings from other websites,” and fake/incentivized ratings can trigger a structured-data manual action that removes rich-result eligibility.
• Formatting: real digits (0–9), period decimal separator (not comma).
• Eligibility ≠ ranking: valid markup only makes the page eligible for stars; it’s not a ranking factor. Bing consumes the same vocabulary but has no comparable eligibility documentation.

Official documentation

Primary-source documentation for AggregateRating.

schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. (the vocabulary)

• AggregateRating type — the baseline type definition, property list (itemReviewed, ratingCount, reviewCount, inherited ratingValue/bestRating/worstRating), and the digit/decimal-separator usage notes.

Google — the eligibility and requirements side

• Review snippet (Review, AggregateRating) structured data — the authoritative spec: required properties, the supported host-type list, the self-serving-reviews scope (LocalBusiness/Organization), and the “don’t aggregate from other websites” rule.
• General Structured Data Guidelines — the spam policies, the manual-action language, and the genuine-ratings requirement.
• Making Review Rich Results more helpful (Sept 2019) — the origin of the self-serving-reviews policy. Cited for the “when/why it changed” context.
• Rich Results Test — validate the markup and check star-rating eligibility.

Bing / Microsoft

• Marking up your site with structured data — Bing’s general structured-data support (schema.org, JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.).

Quotes from the source

On-the-record statements from schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and Google. Where a source page exposes the text, the link is a deep link that jumps to the quoted passage.

schema.org — the type definition

• “The average rating based on multiple ratings or reviews.” Jump to quote

Google docs — marking up an aggregate

• “Make sure to mark up an aggregate evaluation of an item by many people with schema.org/AggregateRating.” Jump to quote

Google docs — the self-serving reviews rule (scoped to LocalBusiness/Organization)

• “If the entity that’s being reviewed controls the reviews about itself, their pages that use LocalBusiness or any other type of Organization structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. are ineligible for star review feature.” Jump to quote

Google docs — don’t aggregate from other sites

• “Don’t aggregate reviews or ratings from other websites.” Jump to quote

Google — structured data policies (deceive/mislead, manual action)

• “Don’t use structured data to deceive or mislead users. Don’t impersonate any person or organization.” Jump to quote
• On genuine ratings (recipe-specific example, generalizable to the reviews policy): “reviews or ratings not by actual users may result in manual action.” General Structured Data Guidelines

AggregateRating vs. Review — which do I need?

Work down the questions:

1. Are you marking up one person’s opinion, or the average of many?

• One reviewer’s opinion (a single rating + review text) → you want Review schema, not AggregateRating.
• The average across many ratings → AggregateRating. Continue.
• Both (an overall score and individual opinions) → use both, nested together in the same parent type: one aggregateRating plus an array of review objects.

2. Are you nesting it, or standing it alone?

• Nesting inside Product (or ProductGroup), Recipe, Movie, Book, Course, Event, or SoftwareApplication → supported host; genuine ratings are normally eligible for stars, and you can omit itemReviewed since the parent already names the item. Continue.
• A LocalBusiness or Organization rating itself → stop. Self-serving ratings here are ineligible for the star feature. Don’t expect stars even if the markup validates.
• Not nesting at all → that’s fine too, as long as AggregateRating supplies itemReviewed naming the rated item directly.
• Some other parent type not on Google’s supported list → the markup may validate, but stars won’t render — it’s an unsupported host.

3. Do you have the required properties?

• Confirm ratingValue and at least one of ratingCount/reviewCount. If you’re not nesting, also set itemReviewed — either way, the rated item needs a name. Missing the count is the #1 failure.
• Off a 1–5 scale? Add bestRating/worstRating or Google may misread it.

4. Are the ratings genuine and on-page?

• Real, user-sourced, about this specific item, and visible on the same page → good.
• Aggregated from other sites, fabricated, or incentivized → don’t — it risks a structured-data manual action, not just a missing snippet.

Rule of thumb: Review is one opinion; AggregateRating is the average of many. Product-and-friends can show genuine stars; a business rating itself cannot.

AggregateRating myths and mistakes to avoid

Myth: “I can add AggregateRating to my Organization/LocalBusiness schemaLocalBusiness schema (schema.org/LocalBusiness) is structured data — usually JSON-LD — that describes a physical business to search engines: its name, address, phone, hours, geo-coordinates, and price range. Google requires only name and address, consumes about a dozen recommended properties, and treats it as a corroborating signal, not a substitute for a Google Business Profile. and get stars like a product does.” No. Google explicitly excludes self-serving ratings on LocalBusiness/Organization from the star review feature — “pages that use LocalBusiness or any other type of Organization structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. are ineligible for star review feature” when the entity controls reviews about itself. This has been the case since the September 2019 policy change. A business rating itself doesn’t get stars; a store rating its products still can.

Myth: “AggregateRating and Review are the same thing.” Review marks up one reviewer’s opinion; AggregateRating marks up the average of many. Distinct types, distinct required properties. Many pages use both, nested together — but they aren’t interchangeable, and using an aggregate doesn’t obligate you to invent individual Review objects to go with it.

Myth: “I only need ratingValue — the count doesn’t matter.” Google requires at least one of ratingCount or reviewCount alongside ratingValue. A bare average with no sample size behind it isn’t eligible.

Myth: “ratingCount and reviewCount are the same number.” They’re different. ratingCount includes star-only submissions with no review text; reviewCount is the number of people who left a review, with or without a rating attached — it isn’t strictly limited to “written reviews.” A page can have 1,200 ratings but only 340 people who left a review. Supply the one your platform actually tracks — don’t inflate either.

Myth: “A third-party review widget on my business page automatically qualifies for stars.” If the widget displays reviews about your own business/organization — even sourced from a third-party platform — it’s still self-serving and ineligible for LocalBusiness/Organization star display.

Myth: “Fake or incentivized 5-star ratings just risk the snippet not showing.” Google frames genuine-ratings-only as enforced — fabricated ratings can trigger a structured-data manual action that removes rich-result eligibility for the page, not merely a suppressed snippet.

Myth: “AggregateRating schemaAggregateRating schema (schema.org/AggregateRating) is structured data that represents the average of many ratings or reviews of an item, usually nested inside a parent type (or standalone with itemReviewed) to power star-rating rich snippets in search results. improves rankings.” Like all schema markupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., it affects rich-result eligibility, not ranking — it earns star-rating eligibility, not position. (The Structured Data hub makes this case in full.)

Mistake: aggregating ratings from other websites. Google’s guidance is a flat “Don’t aggregate reviews or ratings from other websites.” Use only ratings your own page genuinely collected.

Mistake: malformed ratingValue. Use real digits and a period decimal separator (4.6, not 4,6 or look-alike Unicode). Comma decimals are a common, avoidable validation failure.

Mistake: aggregateRating on an unsupported host type. Standing AggregateRating alone with itemReviewed is valid, and nesting it in a supported type is the common pattern — but either way, the item type has to be on Google’s supported list. Put it on an unsupported type and it may validate but won’t render stars.

Clean vs. broken AggregateRating JSON-LD

A clean, nested aggregate rating

AggregateRating correctly nested inside a Product, with a valid average, a count, and the scale spelled out — plus a single review alongside it (the common real-world pattern):

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Trailhead 30L Hiking Backpack",
  "image": "https://example.com/img/backpack.jpg",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "bestRating": "5",
    "worstRating": "1",
    "ratingCount": "1200",
    "reviewCount": "340"
  },
  "review": [
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "James Smith" },
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5",
        "bestRating": "5"
      },
      "reviewBody": "Comfortable on long days, great ventilation."
    }
  ]
}

Note ratingCount (1,200 total ratings) and reviewCount (340 people who left a review) are different numbers — as they usually are in reality.

The non-nested form

Nesting is the common pattern, but AggregateRating doesn’t have to sit inside a Product (or any other host) at all. It can stand alone, as long as it supplies itemReviewed naming the rated item — this is a documented, valid shape, not a workaround:

{
  "@context": "https://schema.org/",
  "@type": "AggregateRating",
  "itemReviewed": {
    "@type": "Product",
    "name": "Trailhead 30L Hiking Backpack"
  },
  "ratingValue": "4.6",
  "bestRating": "5",
  "worstRating": "1",
  "ratingCount": "1200",
  "reviewCount": "340"
}

Same properties, same eligibility rules — the only difference is where itemReviewed lives. Nested, it’s implied by the parent and usually omitted; non-nested, it has to be spelled out.

The same aggregate, broken

Every line flagged below is a real, common validation failure:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Trailhead 30L Hiking Backpack",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4,6"
  }
}

What’s wrong:

• No ratingCount or reviewCount — produces the classic “Either ‘ratingCount’ or ‘reviewCount’ should be specified” error. An aggregate needs a sample size.
• ratingValue: "4,6" — a comma decimal separator. Use a period: "4.6".
• No bestRating/worstRating — tolerable at 1–5, but omit them off a non-default scale and Google misreads it.

And the mistake that validates but still shows no stars: putting this exact aggregateRating on a LocalBusiness or Organization rating itself — it’s self-serving and ineligible for the star feature regardless of clean markup.

Common Search Console / Rich Results Test errors → fixes

Tools for building and checking AggregateRating markup

My Schema Markup Validator is where I’d start once you’ve written the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.. Paste the block (or a full page) and it runs severity-tiered checks against schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor.’s AggregateRating vocabulary and Google’s rich-result requirements — it catches the count-missing error, the comma-decimal mistake, and bestRating/worstRating scale problems described above, and hands back a corrected, copy-pasteable JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. block.

My Rich-Result Eligibility Checker answers a different question: not “is this valid JSON-LD” but “does this specific page qualify for Google’s star rich result.” Paste JSON-LD, an HTML page, or fetch a live URL, and it shows, per type, which required fields (itemReviewed, ratingValue, ratingCount/reviewCount) are present versus missing, plus which recommended fields (bestRating, worstRating) you’re leaving off the default scale.

If you’re starting from a blank page rather than fixing existing markup, my Schema Markup Generator has a focused form for building aggregateRating nested inside Product (or any of the other supported host types) without hand-writing the JSON-LD, and it flags whether each property is Google-required, Google-recommended, or schema.org-only as you fill it in.

Once markup passes those two checks, run the page through Google’s own Rich Results Test — it’s the tool Google actually uses to decide eligibility, so it’s the final word before you ship.

Common AggregateRating problems and how to fix them

The markup validates clean, but no stars ever show in search results

The most likely cause is the self-serving-reviews rule: the aggregateRating is nested inside LocalBusiness or Organization, and the business is rating itself. Google excludes that combination from the star feature entirely, regardless of how clean the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. is. Check the parent type first — if it’s LocalBusiness or Organization, move the rating conversation to genuine product-level reviews instead, since a business can’t earn stars by rating itself but a store can rate its products. The second-most-likely cause is an unsupported host type — aggregateRating nested in a type outside Google’s supported list (Book, Course, Event, LocalBusiness, Movie, Product, Recipe, SoftwareApplication, and the smaller additional list) will validate but never render stars.

Rich Results Test or Search Console flags “Either ‘ratingCount’ or ‘reviewCount’ should be specified”

The aggregateRating object is missing a sample-size property. ratingValue alone isn’t enough — Google requires at least one of ratingCount or reviewCount alongside it. Add whichever one matches what your platform actually tracks (total ratings including star-only submissions, or the number of people who left a review) and re-test.

ratingValue fails validation even though the number looks right

Check for a comma decimal separator ("4,6" instead of "4.6") or a look-alike Unicode digit rather than a real 0–9 character — both are common causes in locales that format decimals with commas, and both are invisible-looking mistakes until a validator flags them.

Validator error: “The best rating value must be greater than the worst rating value”

bestRating and worstRating are set backwards, or worstRating is missing and Google’s 1–5 default doesn’t match your actual scale (a 1–10 or out-of-100 rating left unqualified gets misread against the 1–5 default). Set both explicitly — for example worstRating: 1, bestRating: 5 — whenever your scale isn’t the default.

Search Console shows valid items, but stars still don’t appear in the live SERP

Passing validation and Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. reporting “valid” only means the page is eligible for the star rich result — it doesn’t guarantee Google displays it. This is expected, not a bug to chase: eligibility affects rich-result eligibility, not a promise of display or ranking. If the markup is genuinely valid and eligible, there’s nothing further to fix on the markup side.

Rich results disappeared after previously showing

A structured-data manual action for fabricated or aggregated-from-elsewhere ratings removes rich-result eligibility for the page. Check Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance.’s Manual Actions report first. If there’s no manual action, re-validate the current markup — a template or CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. change can silently break a property (a missing count, a rewritten scale) that was previously correct.

Proving your AggregateRating change worked

Test 1: JSON-LD syntax and required-property validation

Test to run: Paste the updated JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. into my Schema Markup Validator, or run the live page through Google’s Rich Results Test. Expected result: No errors on the AggregateRating block — ratingValue present with a real digit/period-decimal value, and at least one of ratingCount or reviewCount present. Failure interpretation: A flagged missing property means the property genuinely isn’t in the markup you shipped, not a cachingCaching stores a copy of a page or resource — in a browser, a CDN edge node, or a search crawler's own cache — so it can be served again without regenerating or re-downloading it. It isn't a direct ranking factor, but it feeds page speed and crawl efficiency. or renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. issue — re-check the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. source. Monitoring window: Immediate — both tools read the markup directly, no crawl wait. Rollback trigger: Validation still fails after a direct fix — revert the template change and re-diff against the last known-good JSON-LD.

Test 2: Rich-result eligibility for the specific host type

Test to run: My Rich-Result Eligibility Checker against the live URL. Expected result: The page’s parent type (e.g. Product) shows as eligible for the review/star rich result, with itemReviewed correctly resolved. Failure interpretation: If the parent type is LocalBusiness or Organization, “not eligible” is expected behavior (self-serving rule), not a bug — confirm the host type before treating this as a failure. Monitoring window: Immediate. Rollback trigger: An eligible-type page (Product, Recipe, etc.) still shows missing-required-field errors after a fix — the deploy didn’t actually update the markup Google sees; check for caching or a build step overwriting the change.

Test 3: Search Console Enhancement report reflects the fix

Test to run: Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. → the relevant Enhancement report (Product snippets / Merchant listings, depending on your host type) for the affected URLs. Expected result: The page moves from “Invalid” or “Not eligible” into the “Valid” bucket, and the report’s error count for that URL drops to zero. Failure interpretation: Still flagged after Google’s recrawlCrawl frequency is how often a search engine comes back to re-fetch a page it already knows about. Popular pages that change often get refreshed many times a day; stable pages can go weeks or months between crawls — and you influence it indirectly, not by setting a dial. means either the fix didn’t ship to the live page, or a different required property is also missing — re-run Test 1 against the live URL, not a staging copy. Monitoring window: A few days up to roughly a week for Google to recrawl and refresh the report — Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. data lags the live page. Rollback trigger: The Invalid-items count rises after a template rollout instead of falling — that’s a sign the change broke markup on other pages using the same template; pause the rollout.

Test 4: The star snippet actually appears in the live SERP

Test to run: A manual search for a query where the page ranks, checking whether the star rating displays under the listing (a private/incognito window avoids personalization skew). Expected result: Stars and a rating count appear under the result. Failure interpretation: Absence here, with a “Valid” Search Console status, isn’t a failure to fix — display is Google’s discretion, not guaranteed by eligibility. Absence combined with a “Not eligible” or manual-action status means go back to Test 1 or 3. Monitoring window: Google gives no fixed timeline for display; check periodically over the following weeks rather than expecting it immediately after validation passes. Rollback trigger: None on the markup side — there’s nothing to roll back for a display decision Google controls. Only revert if Manual Actions flags the page.

Ongoing KPIs for AggregateRating markup

Metric: Valid items count (Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. Enhancement report) What it tells you: how many of your eligible pages currently have error-free AggregateRating markup — the coverage side of the KPI. How to pull it: Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. → Enhancements → the relevant report (Product snippets / Merchant listings) for your site. Benchmark / realistic range: no universal target — establish your own baseline from the count of pages that should carry the markup (your total eligible-type page count), and track valid items trending toward that number. Cadence: monthly, or immediately after any template/CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. change touching review markup.

Metric: Invalid/error items count (same report) What it tells you: how many pages have broken required properties — the quality side of the KPI, separate from coverage. How to pull it: same Enhancement report, the error/invalid bucket. Benchmark / realistic range: the only honest target is zero; any nonzero count is a real broken page, not statistical noise. Cadence: monthly, and always after a deploy that touches the markup template.

Metric: CTR change on pages that gained star eligibility What it tells you: whether the star snippet is actually translating into more clicks for pages that now show it, versus the eligibility side alone. How to pull it: Search Console PerformanceThe Google Search Console report that shows how your site actually performed in Google Search, built from real impressions and clicks. It reports four metrics — clicks, impressions, average CTR, and average position — and keeps the most recent 16 months of data. report, filtered to the affected pages, comparing CTR for the weeks before and after the markup shipped (Search Console doesn’t cleanly isolate “clicks specifically from a star snippet,” so this is a before/after proxy, not an exact attribution). Benchmark / realistic range: no defensible fixed uplift number to cite — establish your own pre-rollout CTR baseline on the same pages and watch the delta, since it depends heavily on query, position, and competitors’ own rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show.. Cadence: monthly for the first quarter after rollout, then quarterly.

Metric: ratingCount/reviewCount growth over time What it tells you: whether the sample size behind your average is genuinely growing — a flat or shrinking count on a page claiming an active review base is worth investigating before it’s worth marking up. How to pull it: your own review platform, CMS, or database — whatever system is the source of truth the markup pulls from. Benchmark / realistic range: track raw growth against your own history; there’s no external benchmark for “how many ratings a page should have.” Cadence: monthly.

Test yourself: AggregateRating Schema

Five quick questions on schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./AggregateRating, its required properties, and the self-serving-reviews rule. Pick an answer for each, then check.

AggregateRating Schema

AggregateRating schema (schema.org/AggregateRating) is structured data that represents the average of many ratings or reviews of an item, usually nested inside a parent type (or standalone with itemReviewed) to power star-rating rich snippets in search results.

Related: Review Schema, Product Schema, ProductGroup Schema, Organization Schema, Schema Markup, Structured Data

AggregateRating Schema

AggregateRating is the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. type used to mark up the average rating of an item based on many individual ratings or reviews — as opposed to Review, which marks up a single reviewer’s opinion. It’s usually nested inside another type’s aggregateRating property, most commonly Product, but also LocalBusiness, Organization, Recipe, Book, Course, Event, Movie, and SoftwareApplication, among others. Nested, it omits itemReviewed (implied by the parent’s own name); Google also supports a non-nested AggregateRating that supplies itemReviewed directly.

Google reads it to power the star-rating rich snippet in search results. The required properties for that eligibility are ratingValue, at least one of ratingCount or reviewCount, and itemReviewed when not nested; bestRating and worstRating are recommended, especially when your scale isn’t the default 1–5. ratingCount counts all ratings including star-only ones; reviewCount is the number of people who left a review, with or without a rating attached — not strictly “written reviews.”

Eligibility depends on what you nest it in. On Product, Recipe, Movie, and most other supported types, a genuine aggregate rating is normally eligible for stars. On LocalBusiness and Organization, self-serving ratings — a business rating itself — are ineligible for the star review feature, a rule Google introduced in September 2019. Like all structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding., AggregateRating affects rich-result eligibility, not ranking, and fake or manipulated ratings can trigger a structured-data manual action.

Related: Review Schema, Product Schema, ProductGroup Schema, Organization Schema, Schema Markup, Structured Data

Changelog