Review Schema Markup: How to Add It and Earn Stars
Published by The Branded Agency · · 12 min read

Review schema markup is structured data, usually JSON-LD, that tells search engines a page contains a review or an average rating of a specific item. When the markup is valid and meets Google's policies, Google may show the stars and rating summary beside your listing. It is never guaranteed. This guide covers the two types, the required properties, a working example, the self-serving review rule that blocks many sites, and how to test the result.
TL;DR
- Use
Reviewfor one person's evaluation andAggregateRatingfor a summary of many. Each has its own required properties. - Mark up a specific item, such as a product, a recipe or a software application. Do not mark up a category or a list of items.
- Reviews about a business or organization that you place on that same business's own site are treated as self-serving. Google will not show stars for them, even through a third-party widget.
- Test with the Rich Results Test and Search Console. If the markup is not visible there, Google says it is not valid.
- Google may show review rich results when markup is valid, but it does not promise that they will appear.
Table of Contents
- What review schema markup does
- Review vs AggregateRating: the difference that matters
- Which page types can show stars
- A JSON-LD example you can adapt
- The self-serving review rule
- Policies to clear before you publish
- How to test and monitor your markup
- Common implementation mistakes
- See where your structured data stands
- FAQ
- Sources
What review schema markup does
Google describes a review snippet as a short excerpt of a review, or a rating, usually an average of the scores from many reviewers. When Google finds valid review markup, it may show a rich snippet with stars and other summary information. That snippet is what most people mean when they search for star ratings on Google.
The markup does not create the stars. It describes content that is already on the page in a format machines read without guessing. Three consequences follow:
- The rating and the reviews must be visible to users on the page. Google requires that marked-up review content is readily available and clearly visible.
- The markup must match what is shown. A rating of 4.6 in the code and 4.1 on the page is a data quality problem, not a rich result.
- Eligibility is not a promise. Google states that it does not guarantee structured data features will appear in search results.
There is also a reading benefit beyond the blue-link snippet. Structured data gives crawlers and AI systems an unambiguous statement of what is being reviewed, who wrote the review and what the score means. In an audit, we treat that as a trust signal: the clearer the entity and rating data, the less any system has to infer. Our write-up on schema markup deficits and fixes shows how gaps like this surface in practice.
Review vs AggregateRating: the difference that matters
Google treats Review as an individual evaluation and AggregateRating as a summary rating. They are not interchangeable, and they do not share required fields.
| Review | AggregateRating | |
|---|---|---|
| What it represents | One reviewer's evaluation | A summary of many ratings |
| Required by Google | Author, reviewRating with ratingValue, name of the reviewed item |
ratingValue, ratingCount or reviewCount, name of the reviewed item |
| Where it nests | Under the reviewed item with the review property |
Under the reviewed item with the aggregateRating property |
| Typical page | A single review or a product page showing a few reviews | A product or software page that displays many ratings |
The requirements come from Google's review snippet documentation. For aggregate ratings, Google says you must supply the average rating for the rich snippet to display. A count with no average is not enough.
Which should you use? If the page shows a single editorial review, use Review. If the page collects ratings from many customers and shows the average, use AggregateRating. A product page often carries both: a few featured reviews and the overall average.
Which page types can show stars
Google does not award review stars to every schema type. In its 2019 announcement, Making Review Rich Results more helpful, it limited the types that can trigger review rich results to this list: Book, Course, CreativeWorkSeason, CreativeWorkSeries, Episode, Event, Game, HowTo, LocalBusiness, MediaObject, Movie, MusicPlaylist, MusicRecording, Organization, Product, Recipe and SoftwareApplication.
Two practical points sit inside that list.
Review a specific item. Google recommends providing review information about one specific item, not a category or a list of items. A page titled "Best CRM tools" with one rating for the whole page does not fit. A page about a single product, course or application does.
Put the markup on the page where the reviews live. Add AggregateRating only where reviews are actually aggregated and shown. Putting it on a home page that displays no reviews is a mismatch between markup and content, which is the pattern behind many rejected implementations.
For software companies, SoftwareApplication is the natural fit. For physical goods, Product. For courses and events, the matching types. For LocalBusiness and Organization, read the next section before you invest any time.
A JSON-LD example you can adapt
Google recommends nesting an individual review with the review property and an aggregate rating with aggregateRating. Google's Product snippet documentation shows the same pattern: a review under the Product containing a reviewRating with ratingValue and bestRating, an author with a Person name, and an aggregateRating beside it.
Here is a minimal version for a product page. Replace every value with data that is actually on your page.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Example Trail Backpack",
"review": {
"@type": "Review",
"author": {
"@type": "Person",
"name": "Jane Doe"
},
"reviewRating": {
"@type": "Rating",
"ratingValue": "5",
"bestRating": "5"
}
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "128"
}
}
</script>
Things to check before you publish it:
- The product name matches the page. Google requires the reviewed item's name.
- The numbers are real. The
reviewCountshould equal the number of reviews your system holds, and the average should be computed from them. - The scale is explicit. Include
bestRatingwhen your scale is not the default of 5, so a 4 out of 10 is not read as 4 out of 5. - At least one of the required Product fields is present. Google's Product documentation says a product snippet needs at least one of
review,aggregateRatingoroffers. The Rich Results Test may warn if you giveofferswithout a review or rating.
If your site runs on a CMS or a review platform, the plugin may output this for you. You still own the result, so read the generated code in the testing step below.
The self-serving review rule
This is the policy that explains why many business sites never see stars, despite correct code. Google's documentation says reviews perceived as self-serving are not displayed. It defines self-serving as placing reviews about entity A on entity A's own website. That includes reviews embedded through a third-party widget. The rule applies to LocalBusiness and Organization markup.
The 2019 Search Central post explains the reasoning: a widget gives the business control over how reviews are linked to its own entity. Two details are worth knowing:
- You do not need to remove self-serving review markup. Google Search simply will not display review snippets for those pages.
- Other types on the eligible list, such as
ProductandSoftwareApplication, are evaluated for their own content, so a product page with real customer ratings remains a valid use.
That shapes where to put your effort:
- Service businesses and local companies. Treat star ratings in the organic listing as unlikely. Spend the effort on the profile that Google already controls and on the quality of the reviews themselves. Our Google Business Profile audit steps and guidance on replying to negative reviews cover that ground.
- Brand pages. Use Organization schema to state who you are, your logo, your profiles and your contact details, not to bolt a rating onto the homepage.
- Products, courses, software, recipes. These are the realistic candidates for stars. Build the markup on the specific item page.
Policies to clear before you publish
Google's review snippet documentation names several practices that cost you eligibility, or worse:
- Fake or undisclosed incentivized reviews. Do not include them in the markup.
- Aggregating reviews or ratings from other websites. Mark up the reviews you collect and display, not a scraped average from elsewhere.
- Hidden review content. The marked-up reviews must be visible to the reader.
- Category-level ratings. Rate one specific item.
A separate programme has its own thresholds. For Google Merchant Center product ratings, Google's help page says you need a minimum of 50 reviews across all products, and your review data source must be uploaded at least once a month with updated reviews. Participation does not guarantee reviews will be matched to free listings, and reviews typically go live 2 to 4 weeks after a successful data source onboarding. That is a feed-based programme, separate from on-page markup, but retailers often run both.
How to test and monitor your markup
Testing has three stages, and each catches a different problem.
1. Validate the code
Paste the live URL, or the code, into Google's Rich Results Test. Look for errors first, then warnings. Errors block eligibility. Warnings usually flag optional fields.
2. Confirm Google can see it
For markup generated by JavaScript or a plugin, Google's guidance in Rich Results and Search Console is to inspect the URL in Search Console and use the Rich Results Test. Its position is that if the structured data is not visible through those tools, the markup is not valid. View-source is not enough for dynamically injected markup.
3. Monitor after launch
Watch the review snippet reports in Search Console after deployment. Template changes, plugin updates and review platform migrations commonly break markup silently. If you manage many templates, a schema testing automation guide can help you build repeatable checks for rich result warnings instead of spot-checking pages by hand.
A simple release checklist:
- Test one URL per template, not one URL per site.
- Compare the visible rating and count with the markup values.
- Confirm the reviewed item's name is identical on the page and in the code.
- Re-test after any CMS, theme or review platform update.
Our perspective on review markup
We audit review schema as part of a wider question: does the evidence on your public pages say the same thing everywhere? A rating in the code, a rating on the page, a rating on a listing profile and a rating an AI assistant repeats should agree. When they do not, the schema is rarely the root cause. It is the visible symptom of unmanaged review data.
That is why our Brand Health Audit scores structured data against a fixed checklist instead of offering opinions. Each finding is tied to observable public data, and the report separates the score, the data coverage and the confidence, so you know how much weight a result can carry. A missing
AggregateRatingon a product page is a clear, fixable item. A star rating that Google is unlikely to show for a self-serving organization page is a different finding, and it should lead you to a different action.Our recommendation is to fix the foundations first: the right schema type on the right page, honest review counts, a consistent entity description, then monitoring. Stars are a possible outcome of that work, never the goal that justifies shortcuts. Teams that follow this order tend to find that their listings, their AI visibility and their conversion pages improve together because they rest on the same clean evidence.
Quincy
Common implementation mistakes
These are the failures we see most when markup is reviewed against the documentation.
- Rating the wrong page type. Site-wide
AggregateRatingon a homepage that shows no reviews. Move it to pages that actually display the aggregated reviews. - Using Organization markup for self-reviews. The code may validate, but Google will not display the snippet. Validity and eligibility are different tests.
- Rating a list. A roundup page with one rating for ten items. Rate a specific item instead.
- Stale numbers. Hard-coded counts that never update as new reviews arrive. Generate the values from your review data.
- Missing required fields. Reviews without an author, ratings without a count, or no item name.
- Importing third-party ratings. Copying an average from another website violates Google's guidance on aggregating reviews from elsewhere.
- Markup that only exists after a script fails or succeeds inconsistently. Verify it in the URL Inspection tool, as described above.
If your reviews relate to a physical location, make sure the name, address and phone details are consistent across your pages and profiles. Our local presence audit and the local SEO audit checklist cover that part of the picture. For other structured data types that sit beside reviews, see our guides to FAQ schema and B2B schema markup.
See where your structured data stands
If you want to know whether your review markup, Organization data and other schema agree with the rest of your public presence, our Brand Health Audit starts with a free scan of your public data. No sales call and no credit card are required for that initial scan.
When you want the full picture, the full twelve-category audit is $99 one-off. It scores categories including SEO, AEO, GEO and reputation, with recommendations linked to observable data. You can see current plans on the pricing page, or look at the sample brand audit report first to see how findings are presented.
FAQ
Will review schema guarantee star ratings on Google?
No. Google says it may show a rich snippet with stars when it finds valid markup, and it does not guarantee that structured data features appear in search results. Valid code makes a page eligible, and the page must also follow the review policies.
Do I need to delete review markup that Google treats as self-serving?
No. Google states that you do not need to remove self-serving review markup. Search simply will not display review snippets for those pages. Keep your effort on pages where reviews about a specific product, course or application are eligible.
How do I test my schema markup?
Run the live URL through the Rich Results Test, then inspect the URL in Search Console. Google says that if the structured data is not visible through those tools, the markup is not valid. Re-test after every template or plugin change.
What is the difference between Review and AggregateRating?
Review marks up one reviewer's evaluation and needs an author, a reviewRating with ratingValue, and the item name. AggregateRating summarizes many ratings and needs ratingValue, a ratingCount or reviewCount, and the item name.
How many reviews do I need for Google product ratings?
For the Google Merchant Center product ratings programme, Google lists a minimum of 50 reviews across all products, with the review data source uploaded at least monthly. That requirement applies to the feed programme, not to on-page markup.
Sources
- Review Snippet (Review, AggregateRating) Structured Data, Google Search Central
- Making Review Rich Results more helpful, Google Search Central Blog
- Product snippet (Product, Review, Offer) structured data, Google Search Central
- Product ratings eligibility, Google Merchant Center Help
- Rich Results and Search Console, Google Search Central Blog
Recommended
Where this shows up in your audit
These scored categories cover what this article talks about.
Industry brand audits
Accounting & bookkeeping firms brand audit · Architecture & design studios brand audit · Automotive brand audit
Want this handled for you?
Content and search work that builds durable organic visibility.
Content Marketing at The Branded AgencyGoing deeper on the strategy behind it: The strategy thinking behind the audit, written for brand and marketing leads. Insights from The Branded Agency.
Measured against real data
Every figure we publish comes from completed audits, reported as anonymised averages.
Related articles
- Schema Markup Deficits in Your Audit: Meaning and Fixes
Understand schema markup deficits in your audit report. Learn how syntax errors, incomplete entities, and missing nestings impact AI search visibility and SEO scores.
- Copilot SEO: How to Get Your Brand Cited by Microsoft Copilot
Copilot SEO: How to Get Your Brand Cited by Microsoft Copilot! Geometric content path ending at citation card Copilot SEO means making your brand easy for Microsoft Copilot to find, understand and cit
- Sitemap and Indexing Audit: A Step-by-Step Method
Sitemap and Indexing Audit: A Step-by-Step Method! Geometric sitemap and index audit title card A sitemap and indexing audit answers one question: do the URLs you tell search engines about match the U
Stay sharp
Get the next brand breakdown in your inbox
Practical brand strategy, messaging and AI-search insights. No fluff, no daily sends — just the work that moves brands.
Written by
Quincy Samycia
Founder & Brand Strategist, The Branded Agency
Quincy leads brand strategy at The Branded Agency, where he has spent over a decade helping founders and B2B teams sharpen their positioning, messaging and creative systems so growth stops depending on guesswork.
More from Quincy Samycia →See where your brand actually stands
Run the Brand Health Audit and get a scored diagnostic of your messaging, positioning and visibility.
