What this Review and rating validator does
Paste a Review or AggregateRating JSON-LD block and this tool checks whether it is valid, complete, and compliant with Google's review snippet policy. Star ratings in search are one of the most clicked rich results, but they are also one of the most policy-restricted, and broken or non-compliant review markup is a leading cause of lost snippets and even manual actions. The validator inspects the ratingValue range, the author, the itemReviewed, and the policy rules that decide whether Google will trust the markup at all.
Review markup comes in two related shapes. A Review represents one person's rating of one thing, carrying a reviewRating. An AggregateRating summarizes many ratings into an average, carrying ratingValue plus a count of how many ratings or reviews it represents. The validator handles both, applies the right rules to each, and tells you which fields are missing, which values are out of range, and which patterns violate Google's guidelines.
The ratingValue range and the fields around it
The single most error-prone field is the rating value. By default a rating is on a one-to-five scale, but you may set your own bounds with bestRating and worstRating. The validator checks that the ratingValue is a number, that it falls between worstRating and bestRating inclusive, and that the scale itself is sane, meaning bestRating is greater than worstRating. A value of six on a five-star scale, a negative value, or a value expressed as text rather than a number all fail here.
It also checks the supporting count fields. An AggregateRating must declare how many opinions it is based on through ratingCount or reviewCount; an average with no count behind it is not credible to Google and is flagged. The validator confirms these counts are present, are positive integers, and are not zero, since a zero-count aggregate is meaningless. For a single Review, it confirms the reviewRating object exists and itself carries a valid ratingValue, because a review without a rating cannot produce a star snippet.
Author and itemReviewed, the fields people forget
Every Review needs an author, and the validator checks that author is present and properly typed as a Person or an Organization with a name. A bare string sometimes works but the structured object is safer, and an author that is the name of your own business reviewing itself is a policy violation the validator warns about, because Google does not allow self-serving reviews where the entity reviews its own products or services.
Just as important is itemReviewed, the thing being rated. Review and AggregateRating cannot float free; they must attach to a specific item such as a Product, a LocalBusiness, a Recipe, a Book, a Course, or another supported type, and that item needs at least a name. The validator confirms itemReviewed exists, has a usable type, and is one Google permits review snippets for. Markup that rates nothing, or rates a type Google excludes from review snippets, will validate as JSON but never earn the stars, and the validator calls that out.
Google policy compliance checks
Beyond structure, the validator applies Google's review-specific policies, which are stricter than schema.org alone. It flags self-serving reviews, where a site marks up ratings of its own brand on its own site. It flags review markup placed on the wrong kind of page, since reviews must describe a specific item and not a whole site or a category. It watches for ratings that are not based on the visible content of the page, because Google requires that the markup reflect a genuine, on-page review that users can actually see.
It also flags the widely abused pattern of aggregate ratings with implausible or unsupported numbers, and the use of review markup that no longer earns snippets for certain types Google has restricted over time. The point of these checks is that a technically valid Review can still be ignored or penalized if it breaks policy, so the validator separates the question of is this parseable from the more important question of will Google actually trust and show it.
How to read the validation result
Output is split into errors, which block the snippet, and warnings, which threaten or degrade it. Errors include an out-of-range ratingValue, a missing count on an aggregate, a missing author on a review, or a missing itemReviewed. Fix every error before shipping. Warnings include policy risks like self-serving reviews, weak author objects, or an itemReviewed type that is allowed but borderline. Treat policy warnings with real seriousness, because the consequence is not just a missing snippet but potential manual action against your structured data.
Each finding names the field and the problem in plain terms, so a report of ratingValue out of range or itemReviewed missing tells you exactly where to look. A clean result means the markup is structurally sound and policy-aware, but as with every rich result, eligibility is not a guarantee of display.
Common mistakes specific to review markup
The most damaging mistake is the self-serving aggregate, where a business puts star ratings of itself on its homepage. Google explicitly disallows this, and it is a frequent trigger for review-snippet manual actions. The second is a ratingValue that does not respect its scale, often because someone changed bestRating but left a value that no longer fits. The third is an aggregate with no count, which reads as fabricated.
Other common slips include attaching a Review to a vague or missing itemReviewed, formatting the rating as a string like four out of five instead of a number, and marking up reviews that do not appear anywhere on the page. There is also the trap of marking up ratings for content types Google has removed from review-snippet eligibility, which wastes effort on a snippet that can never show. The validator surfaces each of these so you are not relying on a clean JSON parse to mean a working snippet.
Review versus AggregateRating, and where each belongs
The two types answer different questions and the validator applies different expectations to each. A Review captures a single, attributable opinion: one author, one rating, one date, optionally a body of review text. It belongs where an individual critique lives, such as an editor's review of a product or a customer's review shown in full. An AggregateRating, by contrast, is a summary statistic with no single author, representing the average of many ratings and the count behind it. It belongs where you are showing the overall standing of an item rather than one person's take.
Confusing the two is a frequent error. People attach an author to an AggregateRating, which makes no sense because an average has no single author, or they omit the count, which strips an aggregate of its credibility. The validator nudges you toward the right type by flagging an aggregate that carries author-like fields or a review that is missing its single reviewRating. Often a page legitimately carries both at once: an AggregateRating summarizing all ratings of an item, plus several individual Review objects nested under the same itemReviewed. The validator checks that this combination is internally consistent, so the aggregate's count and the individual reviews tell the same story rather than contradicting each other.
Where review markup fits SEO and AI search in 2026
Star ratings remain among the highest-impact rich results for click-through, because a row of stars draws the eye and signals social proof before a searcher reads a word. That power is exactly why Google polices the feature so heavily. Valid, policy-clean review markup on genuinely review-worthy pages, like individual products with real customer ratings, is a strong and durable win.
For AI search, structured ratings give engines a machine-readable measure of sentiment and quality they can incorporate when summarizing or comparing options. An AI assistant weighing products or services can lean on a clean AggregateRating to rank choices. Getting the markup right, and keeping it honest, helps you both in classic stars and in the AI surfaces that increasingly read the same signals. Dishonest or self-serving markup, by contrast, risks being discounted everywhere.
What to do after validation passes
With no errors and policy warnings addressed, run the markup through Google's Rich Results Test on the live page to confirm the review snippet is eligible, then deploy. Double-check that the ratings in your markup match real, visible reviews on the page and that the item being reviewed is something a third party can rate, not your own brand reviewing itself. Request indexing so Google re-evaluates the page.
Watch Search Console's review-snippet enhancement report for parsing confirmation and any policy notices over the following days. If stars do not appear, re-check that the itemReviewed type is snippet-eligible, that the aggregate has a real count, and that the page is not running afoul of the self-serving rule. Keep counts and averages updated as new reviews come in, and re-validate whenever you change how reviews are collected or displayed, since stale or mismatched numbers are both a quality and a policy risk.
Finally, build a habit of validating review markup at the template level on any site that generates product or listing pages at scale. If your platform injects an AggregateRating into every product page, a single template error multiplies into thousands of broken or policy-violating blocks, and a single template fix repairs them all. Validate one representative page per template, confirm the rating range, author, itemReviewed, and counts are all sound, and then trust the template to repeat the correct pattern. Spot-check again whenever you change how ratings are stored or rendered, because the gap between what your database holds and what the markup claims is where review-snippet trouble almost always begins.