Review Schema: Google's Rules for Star Ratings

Review schema is structured data using the schema.org Review and AggregateRating types to describe reviews and ratings that appear on a page. When it follows Google’s rules, it can make the page eligible for a review snippet: stars, a rating and a review count in search results. Those rules are stricter than most templates admit, especially for businesses marking up reviews of themselves.

This guide is for ecommerce teams, publishers and local businesses deciding what review markup they can use. It covers which types can show stars, the 2019 self-serving review rule, the properties Google requires, what leads to a manual action, and a correct example.

On this page

• What is review schema?
• Which types can show review stars?
• Why can’t businesses show stars for their own reviews?
• Review vs AggregateRating: required properties
• What gets a review manual action?
• A correct review schema example
• Does review schema matter for AI answers?
• Getting review schema right on your site

What is review schema?

Review schema is two related schema.org types. Review is “a review of an item”, such as a restaurant, movie or store, written by one author. AggregateRating summarizes many ratings into one average. Schema.org’s usage figure for Review, based on Google’s web index, is 1 to 10 million domains.

Google’s review snippet documentation describes a review snippet as “a short excerpt of a review or a rating from a review website, usually an average of the combined rating scores from many reviewers”, and says snippets may appear in rich results or knowledge panels.

Two points frame everything else. Review markup never stands alone for Google: it has to be attached to a specific item, either nested inside that item or pointing to it with itemReviewed. And it has to describe reviews people can actually see on the page.

Which types can show review stars?

Only reviews of certain item types can produce a review snippet. Google narrowed the list in its September 2019 update to review rich results, saying that for “many types displaying star reviews does not add much value for the user”.

Google’s current documentation also lists HowTo among valid itemReviewed types, but HowTo rich results were retired in 2023, so that entry has little practical value today. For employer reviews there’s a separate type, EmployerAggregateRating.

The practical consequence is that a service business can’t get stars by putting aggregateRating on a Service or on its own LocalBusiness. Product pages are where review markup most often works, as covered in product schema.

Why can’t businesses show stars for their own reviews?

Because Google treats them as self-serving. The 2019 post defines self-serving reviews as those where “a review about entity A is placed on the website of entity A - either directly in their markup or via an embedded third-party widget”. From that change, Google stopped showing review rich results for LocalBusiness and Organization (and their subtypes) when the entity being reviewed controls the reviews. The decision tree below shows how the rule plays out.

The widget point catches many businesses. Google’s FAQ in the same post says pages embedding a third-party widget with reviews about the business won’t get review snippets, because “embedding a third-party widget is seen as controlling the process of linking reviews”. The current guidelines name the examples directly: a Google Business reviews widget or a Facebook reviews widget.

Three reassurances from that FAQ, still relevant:

• You don’t need to remove self-serving markup. Google “just won’t display review snippets for those pages anymore”.
• It isn’t a manual action on its own. “You won’t get a manual action just for this.”
• Your Business Profile isn’t affected. The rule “only relates to organic Search”. Your Google reviews still show on your profile.

The rule applies to Review and AggregateRating alike. Sites that genuinely review other businesses, such as directories and review platforms, are unaffected. For a business, the reviews that matter for search live on your Business Profile and third-party platforms, which is where the local SEO checklist puts the effort.

Review vs AggregateRating: required properties

Use Review for one person’s review and AggregateRating for a summary of many. If a page shows several individual reviews, Google asks you to include an aggregate rating too. The diagram below labels the required parts of each.

Some details from Google’s definitions that are easy to miss:

• The name is required even when nested. Since the 2019 update, the reviewed item’s name is required, and nesting the review inside a Product doesn’t exempt you from giving the product a name.
• Ratings can be numbers, fractions or percentages. Google accepts values like 4, 60% or 6 / 10 and understands the implied scale for fractions and percentages.
• Author names must be real names. An author field over 100 characters makes the page ineligible for an author-based review snippet.
• Individual ratings can be skipped if the marked-up content has both an author and a review date, but aggregate reviews must include the average rating.

What gets a review manual action?

Manual actions come from misleading review markup, not from self-serving markup alone. Google’s review guidelines and its manual actions report name the patterns:

• Invisible reviews. Google’s guidelines say it must be “immediately obvious to users that the page has review content”. Markup for reviews that aren’t on the page, or that sit in hidden elements, falls under “Structured data found on hidden content”.
• Fake or undisclosed incentivized reviews. Google names reviews “not based on a genuine experience” and reviews written in exchange for money, discounts, vouchers or free products without clear disclosure.
• Reviews written by the business. The manual actions list includes “Review written by the site or person providing the service”, with an exception for customer, independent and unpaid editorial reviews.
• No review source. “If a page includes a review, the page must also provide a way to provide a review or clearly show where the reviews come from.”
• Aggregated reviews from elsewhere. “Don’t aggregate reviews or ratings from other websites.”
• Reviews of a category. Reviews must be about a specific item, “not about a category or a list of items”.

The matrix below separates the scenarios that simply lose stars from the ones that risk a manual action.

A structured data manual action removes the page’s rich result eligibility and makes Google ignore its structured data, according to Google’s troubleshooting guidance. It doesn’t remove the page from search. Fix the markup, then request review in Search Console.

A correct review schema example

Here’s a product page with an aggregate rating and one visible customer review, nested inside the Product. Nesting means itemReviewed is omitted, because Google assumes the parent is the item.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Cast Iron Skillet, 10 inch",
  "image": "https://shop.example.com/img/skillet-10.jpg",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.6,
    "reviewCount": 128,
    "bestRating": 5,
    "worstRating": 1
  },
  "review": [
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "Dana Reyes" },
      "datePublished": "2026-08-30",
      "reviewRating": { "@type": "Rating", "ratingValue": 5, "bestRating": 5 },
      "reviewBody": "Heats evenly and came pre-seasoned well enough to fry eggs on day one."
    }
  ]
}

Every number here must match what the page shows: the average, the count and the individual review. Google’s guidelines also say that if you mark up multiple reviews, you should include all the reviews visible on the page, not a flattering selection. Test the live page in the Rich Results Test, which supports Review snippet, and check the syntax in the Schema Markup Validator.

Does review schema matter for AI answers?

Less than the reviews themselves. No AI assistant has published how it uses review markup, and the reviews that shape recommendations mostly live off your site: on your Business Profile, marketplaces and review platforms. When someone asks an assistant for the best option nearby, the answer draws on those sources, as covered in local AI visibility.

What review markup can do is make ratings on your own product pages unambiguous: which product, what average, how many reviews. That’s useful to any system reading the page, and it only works if the numbers are honest. If assistants misstate your ratings or reviews, when AI gets your brand wrong covers how to trace and correct the source.

Getting review schema right on your site

Review schema rewards restraint. Mark up genuine reviews of eligible items, keep them visible, and leave your own business’s testimonials unmarked.

A short policy that keeps you safe:

1. Mark up reviews only on eligible item pages: products, recipes, events, software, courses, books and media.
2. Don’t put aggregateRating on your own LocalBusiness or Organization, and don’t mark up a reviews widget about your business.
3. Collect reviews on your own site with a visible way to leave one, and show the reviewer’s name and date.
4. Keep every marked-up review and rating visible, and include all of them if you include several.
5. Disclose incentives clearly, or don’t use incentivized reviews at all.
6. Generate the numbers from your review system so the average and count update themselves.

Treat the JSON-LD guide as the syntax reference if you’re writing this by hand.

If your templates are marking up testimonials, widgets or ratings that Google now ignores, our schema markup service audits what each page outputs, removes the markup that can’t help, and keeps the review data that can.