Skip to content

Review and AggregateRating schema: rules, examples and errors

How to mark up reviews and star ratings with Review and AggregateRating schema: eligible types, Google's self-serving review rule, required properties and fixes.

By Crawlito · 6 min read

In short

  • Google's review snippet documentation lists a fixed set of types that can be reviewed, including Product, SoftwareApplication, Recipe, Course, Event, LocalBusiness and Organization.
  • Google says pages that use LocalBusiness or another Organization type are ineligible for star review features when the entity controls the reviews about itself.
  • AggregateRating needs itemReviewed, ratingValue and at least one of ratingCount or reviewCount, and Google assumes a 1 to 5 scale when bestRating and worstRating are left out.
  • Google says not to aggregate reviews or ratings from other websites, and the reviews you mark up must be visible on the page.
  • Markup that passes validation can still be ineligible for stars, so check the policy rules as well as the syntax.
On this page

Review and AggregateRating structured data describe reviews and star ratings in a form search engines can read. Google can show them as review snippets, the stars under a result, but only for certain types of thing, only when the reviews are visible on the page, and not for a business marking up reviews of itself on its own site. Most problems with star markup are policy problems, not syntax errors, so a page can pass a validator and still never show stars.

This guide covers which types Google accepts, the self-serving review rule, required properties with working examples, and the common errors.

What Review and AggregateRating are

On schema.org, a Review is one person's review of an item, with an optional reviewRating. An AggregateRating is the average of many ratings, with a count. You usually nest them inside the thing being reviewed, such as a Product:

  • review: one or more individual Review objects.
  • aggregateRating: one AggregateRating summarising all ratings for the item.

Google's review snippet documentation defines what it supports. Other consumers, including AI systems that parse structured data, read the same schema.org vocabulary, but they do not publish rules about stars, so Google's page is the practical reference.

Which types can have review stars

Google lists the types that can be the itemReviewed:

CategoryTypes Google lists
Products and softwareProduct, SoftwareApplication
OrganizationsLocalBusiness, Organization
Creative worksBook, Movie, MusicPlaylist, MusicRecording, MediaObject, Episode, CreativeWorkSeason, CreativeWorkSeries, Game
How-to and foodRecipe, HowTo
Learning and eventsCourse, Event

Anything else, such as a Service, a WebPage or a blog post, is not on the list. You can still describe it with schema.org, but Google does not show review stars for it. If you sell a service, the closest eligible type may be Product for a packaged offering, or the reviews may simply not qualify.

The self-serving review rule

This is the rule that removes most stars. Google says that if the entity 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 example is a review of entity A placed on the website of entity A.

In practice:

  • A dentist marking up patient reviews of the practice on the practice's own site: self-serving, no stars.
  • A SaaS company adding aggregateRating to its Organization markup on its home page: self-serving, no stars.
  • A shop marking up customer reviews of a product it sells: not covered by this rule, because the reviews are of the Product, not of the shop as an organization.
  • A review site with independent reviews of local businesses: eligible, subject to the other guidelines.

Google also has rules for local business ratings specifically: ratings must be sourced directly from users, and you should not rely on human editors to create, curate or compile ratings for local businesses.

The self-serving rule is about eligibility, not a penalty. The markup is valid schema.org, so it may still be read by other systems. It is pointless for stars, and if it does not match what the page shows, it is misleading. Our Organization schema guide and the planned LocalBusiness schema guide cover what to put in that markup instead.

Review

PropertyStatusNotes from Google's documentation
authorRequiredA valid name, shorter than 100 characters, as a Person or Organization
itemReviewedRequiredOmit it when the review is nested in the item through the review property
reviewRatingRequiredCan be omitted for an individual review if the content has both an author and a review date
reviewRating.ratingValueRequiredA number, fraction or percentage
datePublishedRecommendedISO 8601 date
reviewRating.bestRating, worstRatingRecommendedDefault to 5 and 1 when omitted

AggregateRating

PropertyStatusNotes from Google's documentation
itemReviewedRequiredOmit it when nested in the item through aggregateRating
ratingValueRequiredThe average rating
ratingCount or reviewCountOne requiredratingCount is the number of ratings on your site; reviewCount the number of people who left a review
bestRating, worstRatingRecommendedDefault to 5 and 1 when omitted

A working Product example

A product page with an average rating and two visible reviews:

json
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Trail Runner 2",
  "image": "https://www.example.com/images/trail-runner-2.jpg",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.4,
    "bestRating": 5,
    "ratingCount": 87
  },
  "review": [
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "Dana K." },
      "datePublished": "2026-07-14",
      "reviewRating": { "@type": "Rating", "ratingValue": 5, "bestRating": 5 },
      "reviewBody": "Good grip on wet rock and comfortable from the first run."
    },
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "Sam O." },
      "datePublished": "2026-06-30",
      "reviewRating": { "@type": "Rating", "ratingValue": 4, "bestRating": 5 },
      "reviewBody": "Runs half a size small. Otherwise excellent."
    }
  ]
}

Every value here must match the page: the average and count shown near the product name, and the two reviews printed in the reviews section. If you include individual reviews, Google asks for an aggregate rating as well. The Product schema guide covers the rest of the product markup.

For apps, the same pattern applies inside SoftwareApplication. The planned SoftwareApplication schema post goes through that type.

Common errors and how to fix them

ProblemWhy it failsFix
aggregateRating on Organization or LocalBusiness for your own businessSelf-serving reviews are ineligibleRemove it, or move ratings to an eligible item such as a product
Rating not visible on the pageGoogle requires marked-up reviews to be readily available to usersShow the average, count and reviews on the page
Ratings imported from another siteGoogle says not to aggregate reviews or ratings from other websitesMark up only reviews collected on your site, or link to the third-party profile instead
Rating on a category or list pageGoogle asks for reviews of a specific item, not a category or listPut the rating on each item's own page
Missing ratingCount and reviewCountOne is requiredAdd the count shown on the page
A 10-point scale with no bestRatingGoogle assumes 5 as the maximumSet bestRating to 10
author.name like "Verified buyer" or a long sentenceThe author must be a valid name under 100 charactersUse the reviewer's display name
Rating added by JavaScript onlyCrawlers that do not render miss itOutput the JSON-LD in the server HTML

Google also says not to include fake or undisclosed incentivized reviews, and recommends accepting only ratings that come with a review comment and the author's name. Those are content rules, so no validator catches them.

For syntax errors, such as broken JSON or a wrong @type, see JSON-LD errors.

How to test review markup

  1. Validate the syntax with the Schema Markup Validator, which checks against schema.org.

  2. Check Google eligibility with Google's Rich Results Test, which reports whether review snippets are detected and lists errors and warnings.

  3. Compare with the page. Open the live page and confirm the average, the count and each marked-up review are visible.

  4. Check the raw HTML, not only the rendered page, to confirm the JSON-LD is in the server response:

    bash
    curl -s https://www.example.com/products/trail-runner-2 | grep -c '"AggregateRating"'
  5. Watch Search Console's review snippets report after deployment for errors across the site.

Passing these tests means the markup is eligible. Google decides whether to show stars for a given query, and no markup makes that certain.

Frequently asked questions

Can I add star ratings to my service business website?

You can mark them up, but Google treats reviews of a LocalBusiness or Organization on its own site as self-serving, so they are not eligible for stars. Third-party review sites are where those ratings usually appear.

Can I show Google or Trustpilot reviews in my schema?

Google says not to aggregate reviews or ratings from other websites in your markup. You can display a widget for visitors, but do not mark up those ratings as your own.

What is the difference between ratingCount and reviewCount?

ratingCount is the total number of ratings on your site. reviewCount is the number of people who left a review, with or without a rating. Google needs at least one of them.

Do AI search tools use review schema?

AI operators do not publish rules for review markup. Visible reviews in the HTML are readable by any crawler; structured data describes them in a consistent form, but no operator documents a direct effect on answers or citations.

Why do my stars not show after adding valid markup?

Common causes are the self-serving rule, reviews not visible on the page, ratings on a type Google does not list, or simply Google choosing not to show them for that query.

Check your markup in context

Valid JSON-LD is half the job; it also has to match what the page shows and be in the HTML crawlers receive. The free check reads one page's structured data and raw HTML, with no account needed.

Filed under Structure and schema. Topics: structured-data, json-ld, google, ecommerce