The ratings in your reviews database are the strongest trust signal you have, and most sites never expose them to search engines. Mark up AggregateRating and Review in your Product JSON-LD, and Google can render star ratings in the result and pull your rating into AI answers. It is a click-through and citation lift you earned but do not surface.
The reviews exist. Customers wrote them, the site stores them, and they render on the product page for anyone who scrolls. What is missing is the one layer that makes them readable to a machine before a human ever sees the page. Without it, the engine has to infer from loose HTML that a number near some stars is a rating. With it, you hand the engine an explicit statement: this product, this average, this many reviews.
What’s in this piece
- The trust signal hiding in your database
- How review schema becomes stars, and citations
- Where it shows up: rich results and AI answers
- Product, AggregateRating, and Review JSON-LD, done right
- The rules Google enforces on review markup
- How to validate it and keep it live
The trust signal hiding in your database
Trust is the thing a product page is trying to earn, and a rating is the most compact proof of it. A four-and-a-half-star average across a few thousand reviews says more in one glance than any amount of body copy. That number is already yours. It cost nothing extra to produce, because customers generated it, and it is probably already visible on the page.
The gap is that visible to a shopper and readable by a crawler are two different things. Your page shows the stars as styled HTML, maybe an image, maybe a widget injected by a third-party review provider. A person reads that instantly. A search engine sees markup it has to interpret, and interpretation is exactly what structured data exists to remove. Review schema is the difference between hoping Google works out that a rating lives on the page and telling it so in a format built for the purpose.
Most sites stop at the shopper. The data is in the database, the widget paints it for humans, and nobody ever closed the loop to the crawler. That is the field you never exposed.
How review schema becomes stars, and citations
Structured data is a labeling layer. It does not change what a shopper sees. It annotates the page in a vocabulary search engines agree on, so that the engine can lift specific facts out without parsing your layout. When you mark up a Product with an AggregateRating, you are naming the entity and attaching a trusted attribute to it. This is the same shift from strings to things that makes entities, not keywords, the unit search engines actually reason about.
Two payoffs follow. In classic search, a valid rating makes the page eligible for a review snippet: the star row and review count that appear under the title. That snippet raises click-through because it is social proof placed in the result itself, before the click. In AI answers, the effect is quieter but the mechanism is the same. An assistant assembling a recommendation would rather pull a clean, declared rating than reverse-engineer one from a review widget it may not even render. Structured data gives it the cleaner signal, and the cleaner signal is the one more likely to be used.
Where it shows up: rich results and AI answers
In traditional search, the review snippet is a rich result. It is not a ranking boost. It does not move you up the page. What it does is change how your existing position performs, by making the listing more clickable than a plain blue link at the same rank. On a commercial query where several results sit close together, the one wearing stars tends to win the click. That is more return on traffic you are already earning: the same impressions, a higher share of the clicks, with no change in position required. For a category of pages that already rank on page one, this is often the fastest available lift, because it improves the result rather than fighting for a new one.
In AI answers, the surface is different and the payoff is citation and inclusion. When an assistant shortlists products or summarizes what people think of one, a machine-readable rating is a fact it can state with confidence and attribute to you. This is why answer-first product and category pages and clean schema work together: the page states the answer plainly for humans, and the markup states it unambiguously for machines, so both the snippet and the AI answer have something exact to quote.
Product, AggregateRating, and Review JSON-LD, done right
Use JSON-LD in the page head or body. Mark up the Product, attach one AggregateRating for the summary stars, and include individual Review items where it makes sense. A minimal, correct shape looks like this:
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Example Bridesmaid Dress",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "238",
"bestRating": "5"
},
"review": [
{
"@type": "Review",
"author": { "@type": "Person", "name": "A verified buyer" },
"reviewRating": {
"@type": "Rating",
"ratingValue": "5",
"bestRating": "5"
}
}
]
}
The required pieces are the ones engines need to render the snippet: a ratingValue, a count (reviewCount or ratingCount), and bestRating so the scale is unambiguous. Each Review needs an author and a reviewRating. The single rule that trips people up most: the markup has to describe content a user can actually see on that page. If the reviews are hidden behind a tab, loaded by a script that crawlers do not execute, or simply not present, the markup is describing something that is not there, and Google treats that as a reason to withhold the snippet.
The rules Google enforces on review markup
Review snippets are a place Google polices hard, because they are easy to abuse. Two rules matter most.
First, no self-serving reviews. A rating that an entity gives itself, or markup on a page where the reviews are about your company in general rather than the specific thing on the page, is not eligible. The classic failure is putting AggregateRating on your organization or local-business markup to show stars for your whole brand. Google stopped rewarding that years ago. Reviews must be about the product, the recipe, the specific item, and the author of a review cannot be the business selling it.
Second, the content must be genuine and present. The reviews you mark up have to be real reviews, visible on the page, and the aggregate has to reflect them. Inflating a count or marking up reviews you do not display is the kind of thing that gets review snippets suppressed sitewide, not just on one page. And remember that valid markup only buys eligibility. Google renders the snippet at its discretion and can decline even when everything passes, the same way it can overrule a canonical tag you set when its own signals disagree. Structured data is a strong input, not a command.
How to validate it and keep it live
Validate before you ship and monitor after. Run every template that carries reviews through Google’s Rich Results Test to confirm the Product type is detected and the AggregateRating has no errors. Do it per template, not per page, because the bug is almost always in the template that generates the markup, which means it is wrong on every page at once or right on every page at once.
After launch, the Search Console enhancement report for review snippets is where ongoing problems surface: a field that drops out after a redesign, a review provider that changes its output, a count that stops updating. Watch it the way you watch index coverage, as a standing signal rather than a one-time check. Markup rots quietly. A front-end change ships, the schema silently breaks, and the stars disappear from the result weeks later with nothing in the traffic chart to explain why until you go looking.
If you are not sure whether the ratings you already collect are reaching search engines, that is a technical audit question with a quick answer. What is the strongest trust signal already sitting in your database that no crawler can see?