Review schema and star rich results: how genuine ratings earn yellow stars

What review schema actually does

Structured data is a standardized vocabulary, defined by schema.org, that lets you describe the content of a page in a way search engines can read without guessing. Review schema is the slice of that vocabulary dealing with ratings. There are two pieces that matter here. A Review represents a single rating from one reviewer, and an AggregateRating represents the average score and the total count across many reviews. When Google trusts what it reads, it can render that data as a star rich result beneath your listing.

The mechanism is simple, but the trigger is not automatic. Adding valid markup makes a page eligible for a rich result; it does not guarantee one. Google decides case by case whether to display stars, and it can stop displaying them at any time. The markup is a request, not a command, and treating it as a guaranteed feature is the first mistake businesses make.

The reason to bother is click-through. Stars give a result visual weight in a list of ten blue links, and that weight pulls the eye and the click. The lift is the entire business case, which is also why the temptation to cut corners is strong and why Google polices this area closely.

Which schema.org types are eligible for stars

Review snippets are not available for every kind of page. Google publishes a specific list of content types that can earn star rich results, and marking up something outside that list will not produce stars no matter how clean the code is. The list is narrow on purpose, because Google wants ratings attached to things people genuinely review.

The crucial point for residential contractors is what is missing. As of the September 2019 change, self-serving reviews placed on LocalBusiness and Organization markup, the very types most remodelers and home builders used, no longer generate review snippets. You can still use Product markup, and product reviews remain fully eligible, but you cannot simply rate your own company on your own homepage and expect stars to appear.

The September 2019 self-serving review change

On September 16, 2019, Google announced it would stop displaying review rich results for the schema types LocalBusiness and Organization, and their subtypes, when the entity being reviewed controls the reviews. Google calls these self-serving reviews: reviews about entity A that sit on the website of entity A, whether typed directly into the markup or pulled in through an embedded third-party widget (Google Search Central, Making Review Rich Results More Helpful, 2019).

The reasoning was trust. A business rating itself, with no independent check, is the easiest review data to manipulate, so Google simply stopped honoring it for those types. Importantly, the announcement made two things clear: you do not need to remove the markup from your site, and you will not receive a manual action for self-serving reviews alone. Google just will not show the stars for those pages anymore.

This is the single most misunderstood rule in review schema. Years later, plenty of local businesses still embed a five-star widget on their homepage, wire it to Organization markup, and wonder why no stars appear. They are following advice that expired in 2019. The reviews can still live on the page for human visitors; they simply will not earn a search snippet.

Google's rules for honest review markup

Beyond the eligible-type list, Google's review snippet guidelines set firm conditions, and breaking them is where real risk lives. The reviews you mark up must be genuine, unedited comments from real people, and they must be visible to users on the same page that carries the markup. You cannot mark up reviews a visitor cannot see, and you cannot pull ratings from other websites and present them as your own.

The numbers have to line up exactly. If your AggregateRating reports a 4.7 average across 212 reviews, a user must be able to see that 4.7 and that 212 on the page, and the figures in the code must match the figures on the screen. Mismatched, hidden, or invented review data is precisely what Google's structured-data spam policies target, and the penalty is a manual action that can strip every rich result from your site, not just the offending page.

Honest implementation is therefore the only implementation worth doing. The list below covers the requirements that keep markup compliant and the shortcuts that invite trouble.

How businesses get it wrong and what it costs

Most failed review markup falls into a few repeatable patterns. The most common is the self-serving setup described above: a remodeling company rating its own organization and expecting stars that Google stopped showing in 2019. It produces no penalty, just silence, and a lot of wasted effort chasing a result that cannot appear.

The dangerous patterns are the ones that violate the spam policies rather than the display rules. Marking up reviews that are not visible on the page, padding an aggregate count with ratings scraped from Google or Yelp, or pointing review markup at the wrong entity all qualify as marking up misleading or invisible content. When Google catches this, the consequence is not a quiet non-display. It is a structured-data manual action, which can remove rich results across the whole domain and is slow and painful to recover from.

The lesson is to separate two failure modes cleanly. Ineligibility wastes time; policy violation destroys trust. Treating every star as something to engineer rather than earn is what tips a site from the first category into the second.

How WellBuilt implements review schema as a managed service

WellBuilt treats review schema as part of an ongoing technical SEO and reputation workstream, not a one-time code drop. We start by auditing what you already have, the genuine reviews on your page, the platforms they come from, and the markup currently on the site, then we map it against Google's eligible-type list and the September 2019 self-serving rules. In most cases we find businesses are either marking up the wrong type and earning nothing, or sitting on legitimate product or service ratings they have never surfaced.

From there we implement compliant Review and AggregateRating schema, on the right schema.org types, with the rating and review count visible on the page and matched exactly in the code. We never fabricate reviews, scrape ratings from other sites, or wire up self-serving organization markup, because the upside is not worth a manual action that can wipe out every snippet you have. Each implementation is validated in Google's Rich Results Test before it ships.

Then we monitor. Rich-result eligibility shifts as Google updates its guidelines and as your review profile grows, so we track which pages keep their stars, watch Search Console for structured-data issues and manual actions, and adjust as the rules change. If you want to know whether your ratings could be earning stars, and whether your current markup is compliant, book a free Blueprint at /book and we will review it with you.