Technical SEO

Review Schema: When Google Still Shows Stars, and the JSON-LD That Qualifies

Q: What is review schema?

Review schema is Review or AggregateRating structured data that describes a rating of a specific item, such as a product, book, recipe or software app. Google uses it to decide whether a page can show a review snippet, the star rating under a search result. It only considers ratings attached to the item types listed in its review snippet documentation.

Q: What is the difference between Review and AggregateRating?

Review is one author's rating of one item, and needs an author, a rating value and the item's name. AggregateRating is the average of many ratings, and needs a rating value, the item's name and either ratingCount or reviewCount. If a page marks up several individual reviews, Google asks you to include an aggregate of them as well.

By Nadia Mohamed · 30 September 2026 · 18 min read

Review schema is Review or AggregateRating structured data that tells Google a page contains a rating of a specific item, and it is the markup behind the gold stars of a review snippet. Google only considers it for a fixed list of item types, only when the reviews are visible on the page, and never when a business marks up reviews of itself.

Most guides to review schema start with the JSON-LD and leave eligibility to a footnote. This one starts with eligibility, because that is where implementations fail: which item types Google still supports, the self-serving rule, third-party widgets, critic versus user reviews, and then the markup for Review and AggregateRating, what a SaaS or course site can and cannot mark up, and how to check and monitor it in Search Console.

Key takeaways

Google’s review snippet documentation names a fixed set of item types. A rating attached to anything else, such as a service page or an article, is not a review snippet candidate however valid the JSON-LD is.
A LocalBusiness or Organization that controls reviews about itself is ineligible for stars, whether the markup is hand-written or comes from an embedded widget. This has been the rule since September 2019.
Review is one person’s rating of one item; AggregateRating is the average of many. Both need the item’s name, and an aggregate needs ratingCount or reviewCount.
You cannot import ratings from G2, Trustpilot or any other site into your own markup: Google’s guidelines say not to aggregate reviews or ratings from other websites.
The Rich Results Test checks syntax, not eligibility. Self-serving and fake-review problems pass it and still get no stars.

What review schema is, and what Google does with it

Google defines a review snippet as a short excerpt of a review or a rating from a review website, usually an average of many reviewers’ scores. When it finds valid markup, it may show stars and summary information in a rich result or a knowledge panel.

Two schema.org types do the work:

Review: one author’s evaluation of one item, with a reviewRating.
AggregateRating: the average rating of an item across many people, with a count.

You can publish either on its own, pointing at the item with itemReviewed, or nest it inside the item’s own markup using the item’s review or aggregateRating property. Google treats the nested form as a review of the parent item, so itemReviewed is omitted there.

“May show” is doing real work in that description. Google states that it does not guarantee that features that consume structured data will show up in search results. Valid, eligible markup is the entry ticket, not the result. Whether the stars are worth chasing at all is a separate question, covered in do rich snippets help SEO.

Which item types can still show stars

This is the part most review schema guides get wrong by omission. Google does not show stars for a rating attached to any type you like. In 2019 it limited the pool of schema types that can trigger review rich results, and the current documentation keeps that limit.

As of September 2026, the review snippet documentation (last updated 8 September 2026) lists the valid types for the reviewed item as:

Item type	Notes from Google’s current docs
`Book`	Listed as a feature you can supply ratings for
`Course`	Listed; see the course caveat below
`CreativeWorkSeason`, `CreativeWorkSeries`, `Episode`	Supported schema.org types, with subtypes
`Event`	Listed as a feature you can supply ratings for
`Game`	Supported schema.org type
`HowTo`	Still in the valid-types list; see below
`LocalBusiness`	Only for sites that capture reviews about other local businesses
`MediaObject`, `MusicPlaylist`, `MusicRecording`	Supported schema.org types
`Movie`	Listed as a feature you can supply ratings for
`Organization`	Only for sites that capture reviews about other organisations
`Product`	Listed; the most common real-world use
`Recipe`	Listed as a feature you can supply ratings for
`SoftwareApplication`	Listed; a rating or review is required for the software app rich result

Subtypes count. A Restaurant is a LocalBusiness, a MobileApplication is a SoftwareApplication, and a Car needs special handling: Google says Car isn’t supported automatically as a subtype of Product, so you declare both types if you want ratings on it.

Three entries deserve a closer look.

HowTo is still in the valid-types list, but the HowTo rich result is not in Google’s current search gallery, which describes review snippets as being about books, recipes, movies, products, software apps and local businesses. Do not plan traffic around stars on a how-to page.

Course is a valid reviewed type, but the course list documentation defines only name, description, provider and the list markup, says nothing about ratings, and needs at least three courses. A rating on a course is legitimate markup with an uncertain display outcome.

Services, articles and plain web pages are missing entirely. There is no Service, Article or WebPage in the list, so an AggregateRating on a services page, a landing page or a blog post cannot produce a review snippet, even before the self-serving rule applies.

The self-serving rule: why your homepage stars disappeared

The rule most sites run into is the one about reviewing yourself. Google’s current wording, under the review snippet guidelines, is that if the entity that’s being reviewed controls the reviews about itself, its pages that use LocalBusiness or any other type of Organization structured data are ineligible for the star review feature.

Google’s own example makes it concrete: a review about entity A placed on entity A’s website, either directly in the markup or through an embedded third-party widget such as a Google Business reviews or Facebook reviews widget.

This dates from September 2019, when Google said it would no longer display review rich results for LocalBusiness and Organization (and their subtypes) when the entity being reviewed controls the reviews. The FAQ on that post settles the usual questions. You do not need to remove the markup, and it will not earn a manual action on its own. The rule covers both Review and AggregateRating. It does not affect your Business Profile, and review sites that rate other organisations are unaffected.

There are two further rules for local business and organisation reviews. Ratings must be sourced directly from users, and human editors must not create, curate or compile ratings information for local businesses.

The practical consequence for most company websites: the testimonial carousel on your home page, marked up as an AggregateRating on your Organization, earns nothing in Search. Leave the testimonials for the humans who read them. Your Organization markup has a different job, which is identity, and that is covered in the Organization schema guide.

Third-party review widgets

Review platforms sell embeddable widgets, and many inject AggregateRating JSON-LD into the host page. Two separate Google rules make that markup ineligible in the common cases.

The first is the self-serving rule above. An embedded widget showing reviews of your business, on your business’s site, is exactly the example Google gives. The 2019 FAQ is explicit that embedding a third-party widget is seen as controlling the process of linking reviews.

The second applies to every item type, including products and apps: the technical guidelines say don’t aggregate reviews or ratings from other websites. A widget that pulls your average score from a review platform and writes it into your product page’s markup is republishing another site’s aggregate as your own.

The widget pattern that stays within the rules is a platform that collects reviews on your own pages, for items on the supported list, and renders the reviews visibly on the page it marks up. Before installing any widget, open a page with it in the Rich Results Test and read exactly which nodes it adds. Some attach the rating to an Organization node, which puts you straight back under the self-serving rule.

Critic, editorial and user reviews

Review markup covers three different kinds of review, and Google treats them differently.

Critic reviews had their own feature once. Google’s documentation changelog records that on 10 June 2021 it deprecated the critic review documentation, having found the markup “wasn’t useful for the ecosystem at scale”. The same entry says the deprecation did not affect other features that use review markup, and that the markup can stay on your site.

Editorial reviews are a single expert’s review of an item, the typical product review article. The markup is a Review nested in the item, with a named author. For products, Google adds an extra: positiveNotes and negativeNotes for pros and cons. The product snippet documentation says only editorial product review pages are eligible for the pros and cons appearance, not merchant product pages or customer reviews, and it requires at least two statements in any combination of pros and cons.

User reviews are the ratings your customers leave. They are what AggregateRating summarises. Google recommends only accepting ratings that are accompanied by a review comment and the author’s name. It is a recommendation, not a requirement, and it was added to the guidelines in January 2025 according to the documentation changelog.

One newer rule covers all three. In July 2026 Google added a guideline about fake and undisclosed incentivised reviews. The review snippet guidelines now say not to include reviews that aren’t based on a genuine experience, or reviews written in exchange for money, discounts, vouchers or free products without clear and prominent disclosure.

Review vs AggregateRating: the required properties

Both types are defined in the same Google document. These are the properties Google requires and recommends, as of the September 2026 version of the review snippet documentation.

Review

Property	Status	What Google says
`author`	Required	A `Person` or `Organization` with a valid name, shorter than 100 characters
`itemReviewed`	Required unless nested	One of the valid types above
`itemReviewed.name` (or the parent’s `name`)	Required	Still required when the review is nested
`reviewRating`	Required	A `Rating`
`reviewRating.ratingValue`	Required	A number, fraction or percentage
`datePublished`	Recommended	ISO 8601 date
`reviewRating.bestRating` / `worstRating`	Recommended	Default to 5 and 1 when omitted

AggregateRating

Property	Status	What Google says
`itemReviewed`	Required unless nested	One of the valid types above
`itemReviewed.name` (or the parent’s `name`)	Required	Still required when nested
`ratingCount` or `reviewCount`	At least one required	Ratings on your site, or people who left a review
`ratingValue`	Required	The average, as a number, fraction or percentage
`bestRating` / `worstRating`	Recommended	Default to 5 and 1 when omitted

Four details catch people:

The scale defaults to 1 to 5. Some guides say worstRating defaults to zero. Google’s documentation says if worstRating is omitted, 1 is assumed. If your scale is 0 to 10, state both ends.
Decimals use a dot. Google asks for 4.4, not 4,4. In Microdata or RDFa you can show a comma to readers and put the dot in a content attribute.
The author must be a name. Google’s example of an invalid reviewer name is a promotional string. For products, it recommends a person’s name or a team name such as “CNET Reviewers”.
Say what is reviewed once. Google’s changelog records a November 2025 clarification that site owners should avoid using multiple ways of indicating what’s being reviewed. Nest the rating or use itemReviewed, not both.

The content rules sit alongside the properties. The reviews you mark up must be readily available to users on the page, a rating must be about a specific item rather than a category or list, and if you mark up several individual reviews you should also include an aggregate of them.

JSON-LD that qualifies

Each block below parses as JSON and follows the required properties for its type. Replace the example values with what is visibly on your page; nothing here should be copied as data. For general placement and syntax, see how to create rich snippets with JSON-LD.

An editorial review of a product, with pros and cons

One named author, one rating, and the pros and cons that only editorial review pages can use. The review is nested, so there is no itemReviewed.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Example Standing Desk Pro",
  "image": "https://www.example.com/images/standing-desk-pro.jpg",
  "review": {
    "@type": "Review",
    "name": "Example Standing Desk Pro review",
    "author": {
      "@type": "Person",
      "name": "Jane Smith"
    },
    "datePublished": "2026-09-12",
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": 4,
      "bestRating": 5,
      "worstRating": 1
    },
    "positiveNotes": {
      "@type": "ItemList",
      "itemListElement": [
        { "@type": "ListItem", "position": 1, "name": "Stable at full height" },
        { "@type": "ListItem", "position": 2, "name": "Quiet motor" }
      ]
    },
    "negativeNotes": {
      "@type": "ItemList",
      "itemListElement": [
        { "@type": "ListItem", "position": 1, "name": "Cable tray sold separately" }
      ]
    }
  }
}

Customer ratings on your own product page

The merchant pattern: individual reviews collected on this page, plus the aggregate of them. Because there are several reviews, the aggregate is included, as Google’s guidelines ask.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Example Standing Desk Pro",
  "sku": "ESD-PRO-120",
  "image": "https://www.example.com/images/standing-desk-pro.jpg",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.5,
    "bestRating": 5,
    "worstRating": 1,
    "reviewCount": 2
  },
  "review": [
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "Sam Patel" },
      "datePublished": "2026-08-02",
      "reviewBody": "Solid at standing height and easy to assemble.",
      "reviewRating": { "@type": "Rating", "ratingValue": 5 }
    },
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "Alex Moreno" },
      "datePublished": "2026-08-19",
      "reviewBody": "Good desk, but the cable tray should be included.",
      "reviewRating": { "@type": "Rating", "ratingValue": 4 }
    }
  ]
}

The aggregateRating values must match what the page shows, and they must describe reviews collected here. A product with a real review history would show a larger reviewCount; the point is that the number is yours, not a platform’s.

A software application with user ratings

The software app documentation requires name, offers.price (use 0 for a free app) and either aggregateRating or review. applicationCategory and operatingSystem are recommended, and the category must be one of Google’s supported values such as BusinessApplication.

{
  "@context": "https://schema.org",
  "@type": "WebApplication",
  "name": "Example Scheduler",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Web browser",
  "offers": {
    "@type": "Offer",
    "price": 0,
    "priceCurrency": "GBP"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.6,
    "ratingCount": 312,
    "bestRating": 5,
    "worstRating": 1
  }
}

WebApplication is one of the two subtypes Google supports alongside SoftwareApplication; MobileApplication is the other.

A standalone review of a book

When a page reviews something it does not sell or own, such as a book review on a blog, the Review can stand on its own and point at the item with itemReviewed. The name inside itemReviewed is required.

{
  "@context": "https://schema.org",
  "@type": "Review",
  "itemReviewed": {
    "@type": "Book",
    "name": "An Example Guide to Technical SEO",
    "author": { "@type": "Person", "name": "Chris Author" },
    "isbn": "9780000000002"
  },
  "author": { "@type": "Person", "name": "Jane Smith" },
  "datePublished": "2026-09-01",
  "reviewBody": "Clear on crawling and rendering, thin on international SEO.",
  "reviewRating": {
    "@type": "Rating",
    "ratingValue": 7,
    "bestRating": 10,
    "worstRating": 1
  }
}

The 10-point scale is declared, so Google does not read a 7 as a 7 out of 5. The same reviewer author pattern your Article schema uses applies here: Google points to its author markup best practices for review authors too.

What a SaaS or course site can and cannot mark up

The two business types most likely to want stars are also the ones most likely to be ineligible. Read against Google’s current documents, this is where the lines fall.

Scenario	Eligible for a review snippet?	Why
G2 or Capterra average copied into your product’s `AggregateRating`	No	Aggregating reviews or ratings from other websites is against the guidelines
Customer testimonials marked up as `AggregateRating` on your `Organization`	No	Self-serving: the entity controls reviews about itself
A review widget on your site rating your company	No	The embedded-widget example Google gives for self-serving reviews
Ratings collected in your app or on your pricing page, attached to `SoftwareApplication` and shown on the page	Yes, on the documentation’s wording	`SoftwareApplication` is a supported type and the self-serving rule names only `LocalBusiness` and `Organization`
Stars on a feature or services page	No	`Service` and `WebPage` are not in the valid types list
Learner ratings on a course page, visible on the page, attached to `Course`	Valid markup, display uncertain	`Course` is supported for reviews, but the course list feature defines no rating properties
A blog comparing other companies’ tools, each with an editorial `Review` of a `SoftwareApplication`	Yes	Third-party editorial reviews of supported types; a page should still be about a specific item, not a list

The SaaS row is an inference from what the documentation says and does not say: Google names LocalBusiness and Organization in the self-serving rule and does not extend it to SoftwareApplication. That covers genuine, on-page user ratings of your app. It is not a licence to wrap company testimonials in SoftwareApplication, and the “genuine experience” guideline still applies. For courses, ship ratings only if they are real and visible, and measure rather than assume. The wider SEO picture for these two business models is in SEO for SaaS and, for learning platforms, custom edtech software.

Why the stars do not show

When the markup validates and the stars still do not appear, rule out the eligibility problems above first: an unsupported item type, reviews about yourself, or an imported aggregate. Then check these:

The rating is not on the page. Google requires review content to be immediately obvious to users. Reviews that exist only in JSON-LD fail this.
The page is not indexable. Google’s own implementation steps tell you to make sure the page is not blocked by robots.txt, a noindex tag or a login. A noindex sent in an X-Robots-Tag header is easy to miss because it never appears in the HTML.
The markup is injected late. For product pages, Google recommends putting Product structured data in the initial HTML. Client-rendered markup is readable, but it is a weaker bet; JavaScript SEO covers why.
Google chose not to. Eligible markup is still not guaranteed a rich result.

There is one more cause no tool will flag. If a page has a structured data manual action, Google says the structured data on the page will be ignored, although the page can still appear in results. Check the Manual Actions report before debugging syntax.

How to check eligibility and monitor in Search Console

Validation and eligibility are different checks, and each tool answers only one of them.

Before launch. Run the page through the Rich Results Test and fix critical errors. Google is explicit about its limit: guideline problems such as spammy content or markup may not be a syntax issue, so the Rich Results Test won’t be able to identify them. A self-serving Organization rating passes the test and still gets no stars. The eligibility checks in the sections above are manual.

After launch. Deploy to a few pages first and use URL Inspection to confirm how Google sees them. Then watch the rich result reports. In Search Console, rich result reports sit under Enhancements, and Review snippets is one of them. Product snippets and merchant listings are under Shopping, so ratings nested in Product markup usually surface there rather than in the Review snippets report.

Three things to know when reading those reports:

They count items, not pages, and they show a sample, not a complete list.
A report only appears once Google finds valid markup of a supported type. No report is itself a finding.
After a template change, Google’s guidance is to watch for an increase in invalid items, and to treat a fall in valid items with no matching rise in invalid ones as a sign the markup is no longer being output at all.

Ongoing. The Performance report shows how often pages appear as a rich result and how often those results are clicked. Filter by search appearance to isolate them, and compare the same pages before and after the markup ships. Ratings go stale, templates change and widgets update their injected JSON-LD, so re-check on a schedule rather than once. A quarterly pass inside a technical SEO audit is enough for most sites, and it is the kind of check we run as part of GEO and technical SEO work.

Frequently asked questions

What is review schema?

Review schema is Review or AggregateRating structured data that describes a rating of a specific item, such as a product, book, recipe or software app. Google uses it to decide whether a page can show a review snippet, the star rating under a search result. It only considers ratings attached to the item types listed in its review snippet documentation.

Can I add review schema to my own business or homepage?

You can add it, but Google will not show stars for it. Since 2019, pages where a LocalBusiness or Organization controls reviews about itself are ineligible for the star review feature, whether the markup is hand-written or comes from an embedded third-party widget. Google says you do not need to remove the markup, and that it will not cause a manual action on its own.

What is the difference between Review and AggregateRating?

Review is one author’s rating of one item, and needs an author, a rating value and the item’s name. AggregateRating is the average of many ratings, and needs a rating value, the item’s name and either ratingCount or reviewCount. If a page marks up several individual reviews, Google asks you to include an aggregate of them as well.

Can I show my G2, Capterra or Trustpilot rating in my schema?

No. Google’s review snippet guidelines say not to aggregate reviews or ratings from other websites. You can link to those profiles and quote them on the page, but the rating in your structured data must come from reviews collected and shown on your own page.

Does Google still show review stars in 2026?

Yes, for supported item types. As of September 2026 the review snippet documentation is current and lists types including Product, Recipe, Book, Movie, SoftwareApplication and Event. What has narrowed is eligibility: self-serving reviews, services and article pages do not qualify, and Google has added guidelines against fake and undisclosed incentivised reviews.

How do I check if my review schema is working?

Test the page in the Rich Results Test to catch syntax errors, then use URL Inspection after deployment to see how Google reads the live page. Monitor the Review snippets report under Enhancements in Search Console, or Product snippets under Shopping for product ratings. Remember that the Rich Results Test cannot detect guideline problems such as self-serving reviews.

Where this fits

Service GEO & Technical SEO Architecture Audit Read → More like this All Technical SEO articles Read → Talk to me Book a 30-min discovery call Read →