--- title: "Review and AggregateRating schema: Google's real required fields" url: https://seomadman.com/research/review-aggregaterating-schema-requirements section: research published: 2026-08-04T00:00:00.000Z modified: 2026-08-04T00:00:00.000Z author: Adam Hafez topics: ["Structured data"] --- # Review and AggregateRating schema: Google's real required fields ## The short answer Google's review-snippet documentation requires itemReviewed, author, and reviewRating for a single review, or ratingCount/reviewCount plus ratingValue for an aggregate rating, and it bans self-serving reviews, undisclosed incentivized reviews, and markup users cannot see on the page itself, exact rules most implementations never actually check against. ## Key takeaways - A single Review needs author, itemReviewed with an eligible @type, and a reviewRating carrying a ratingValue, per Google's documented required-property list. - An AggregateRating needs itemReviewed plus at least one of ratingCount or reviewCount, and Google states explicitly that at least one of the two is required. - Google's guidelines make a LocalBusiness or Organization page ineligible for the star feature when the reviewed entity controls the reviews about itself on its own site. - Google's technical guidelines require marked-up review content to be readily visible to users on the same page, not hidden markup with no matching on-page text. - Google states plainly that if bestRating is omitted a 5 is assumed and if worstRating is omitted a 1 is assumed, so the default scale is 1 to 5 unless declared otherwise. Most guidance on review schema repeats the same short list, add reviewRating, add an author, done. Google's own review-snippet documentation is longer than that list and stricter than it, because it does not only name required properties, it also names behavior it will disqualify a page for even when every property is technically present. The gap between "markup that validates" and "markup Google will actually show a star for" is exactly where most implementations fail. ## The real required and recommended properties Google's documentation splits into two eligible cases, and each has its own required set rather than one shared list. A single **Review** needs `author` (a `Person` or `Organization`, with what Google calls a valid name shorter than 100 characters), `itemReviewed` when the review is not nested inside the item it reviews, and `reviewRating` carrying a numeric `ratingValue`. The `itemReviewed` type has to be one Google actually recognizes for this feature: its documented list names, among others, Book, Course, Event, LocalBusiness, MediaObject, Movie, Organization, Product, Recipe and SoftwareApplication. A review of anything outside that list does not qualify for the star snippet regardless of how the rest of the markup is built. An **AggregateRating** without individual reviews attached needs `itemReviewed`, a numeric `ratingValue`, and, in Google's own words, at least one of `ratingCount` or `reviewCount`. Neither one alone with the other missing satisfies the rule; the documentation is explicit that one of the two specific properties must be present, not that a count of any kind is enough. Google's recommended, non-required additions are `datePublished` on a Review, and `bestRating` and `worstRating` on either a Review's `reviewRating` or an `AggregateRating`. Those three are worth adding but do not block eligibility on their own if a page is otherwise correctly built. ## The real documented abuse and validation rules The properties above are structural. Google separately disqualifies pages on behavior, and this is the part implementations miss because a validator that only checks property presence has nothing to say about it. The rule with the most practical bite is the self-serving one. Google's guidelines state that when the entity being reviewed controls the reviews about itself, a page using `LocalBusiness` or any other `Organization` type is ineligible for the star review feature, and that this applies whether the markup is direct or served through an embedded third-party widget. A business publishing testimonials about its own services on its own site, marked up as `LocalBusiness` reviews, is the exact shape this rule targets. It does not reach `Product` review markup on a retailer's own product pages, since the rule is scoped to `LocalBusiness` and `Organization` types specifically, which is why product review widgets remain common while self-hosted business-testimonial schema does not qualify. Separately, Google's technical guidelines ban fake or undisclosed incentivized reviews outright, defining the category to include reviews that are not based on a genuine experience of the product or service, and reviews written in exchange for money, discounts, vouchers, or free products that do not clearly and prominently disclose that incentive. A page can satisfy every required property and still fail this rule if the reviews behind the markup were bought without disclosure. The visibility rule closes the remaining gap: Google's guidelines require that the review content being marked up is readily available to users from the same marked-up page, stating it must be immediately obvious to users that the page has review content. Markup describing reviews with no matching visible text on the page is a documented violation on its own, independent of whether `ratingValue`, `author`, and `itemReviewed` are all correctly filled in. On the numeric scale, Google's documentation states the default is a 5-point scale, 1 lowest to 5 highest, and that a missing `bestRating` is assumed to be 5 while a missing `worstRating` is assumed to be 1. Neither property is required, but a site using a different scale, a 10-point or a 100-point rating, has to declare both explicitly or Google will read the value against the wrong default range. ## Why we care Every one of these rules is checkable against a live page in minutes: does `itemReviewed` carry an eligible type, is `ratingCount` or `reviewCount` present, does the reviewed entity control the reviews on a `LocalBusiness` or `Organization` page, is the review text actually visible where the markup claims it is, and does the declared scale match `bestRating`/`worstRating` if it is not 1 to 5. None of that requires guessing at Google's intent, all of it is stated on the documentation page itself. What Google's own reported numbers say about how often sites actually violate these rules at scale, rather than what the rules are, is covered on this site by [Google's review-fraud enforcement scale report](/reports/google-review-fraud-enforcement-scale), which traces Google's 2025 Maps enforcement totals separately from the rule text covered here. ## Frequently asked questions ### Does a page need both an individual Review and an AggregateRating? No. Google's documentation treats them as two separate eligible cases. A single Review needs author, itemReviewed, and reviewRating with a ratingValue. An AggregateRating needs itemReviewed, a ratingValue, and at least one of ratingCount or reviewCount. A page can carry either or both, but each case has to satisfy its own required properties on its own. ### Can a business mark up reviews of its own product on its own site? Only within limits Google states directly. The reviewed entity controlling the reviews about itself, on a page using LocalBusiness or any Organization type, makes that page ineligible for the star feature, whether the markup is direct or served through an embedded third-party widget. Product review markup on a retailer's own product pages is the common case that is not blocked by this specific rule, since it targets LocalBusiness and Organization types. ## Sources 1. [Review snippet (Review, AggregateRating) structured data](https://developers.google.com/search/docs/appearance/structured-data/review-snippet) - Google Search Central (primary)