How Google Verifies Review Markup: Visible Content, Real Users, and Manual Actions

Adding Review schema markup is the first step, not the finish line. Plenty of sites publish clean JSON-LD, watch the Rich Results Test come back green, and then wait months for star ratings that never arrive.

The reason is that Google evaluates more than your code. Google’s general structured data guidelines split the rules into technical guidelines, which validators can test, and quality guidelines, which Google itself describes as not easily testable by any automated tool.

Visibility, authenticity, and relevance all sit on the quality side, which is why a green checkmark tells you so little. Understanding how Google verifies review markup is what turns valid schema into visible stars.

Quick Checklist: Review Markup Verification by Google

Google verifies review markup by checking that:

• Reviews are visible to users on the marked-up page, not hidden in code
• Ratings represent genuine user feedback, not fabricated or self-created reviews
• The schema type is eligible and describes one specific item
• The markup complies with Google’s review snippet and structured data guidelines
• No spam signals are present, such as misleading or inflated ratings

Even technically valid Review schema markup can fail to qualify for rich results if it contains self-serving reviews, hidden content, misleading ratings, or other guideline violations.

What Google Checks Before Showing Review Rich Results

Google review schema verification happens after parsing, when automated systems compare your structured data against the rendered page and Google’s published guidelines. Review markup eligibility comes down to a handful of checks that run before any star ever appears.

The last row is the only one a validator confirms. The other five are judgment calls Google makes against your live page, which is exactly why so many site owners report perfect validation alongside zero stars. The broader path to rich snippets on Google follows the same logic across every rich result type.

Visible Content Requirement: Why Hidden Reviews Don’t Count

Google’s rule here is short and unambiguous: don’t mark up content that isn’t visible to readers of the page. Review markup visible content is the reference point for everything else.

Google can process the page content alongside your structured data. When the markup doesn’t accurately represent the content users can access on the page, the page may not qualify for the review rich result.

Several patterns fail this check:

• Reviews that exist only in code. The most common failure. A plugin injects a site-wide aggregateRating into every page, including pages that have never displayed a single review.
• CSS-hidden reviews. Content set to display:none or collapsed behind a tab that never loads content isn’t considered visible.
• Content served only to crawlers. Showing reviews to Googlebot and not to users is cloaking, which falls under Google’s spam policies.
• Mismatched ratings. Your markup says 4.8 from 312 ratings, your page shows 4.2 from 40. That mismatch is checkable.
• Copied testimonials. Quotes lifted from another site and marked up as your own reviews fail both the visibility and the authenticity test.

There’s one more rule worth knowing: if a page displays multiple reviews, mark up all of them. Selecting only the five-star reviews while omitting the critical ones misrepresents the page.

Why Reviews Must Come From Real Users

Google’s review snippet guidelines require original content that you or your users generated, and specifically name fake reviews as misleading markup. The documentation adds a direct warning: ratings not written by actual users may result in a manual action.

Reviews from real users means customer reviews collected on your own site. Verified purchase reviews are stronger, since the purchase record backs the authenticity claim. Editorial and critic reviews can qualify but face stricter guidelines around honest, unbiased representation.

What fails is broader than most people assume: staff-written testimonials framed as customer feedback, fabricated ratings, and placeholder values a developer left in during a theme build.

On AI-generated reviews, the accurate framing matters. Google hasn’t published anything about detecting AI-written review text specifically. What it evaluates is authenticity and policy compliance, and a review no real customer submitted fails the user-generated requirement regardless of how it was written.

Self-Serving Reviews and Why Google Restricts Them

For LocalBusiness and Organization structured data, a self-serving review is a review about the entity published on its own website, either directly in the markup or through an embedded third-party widget.

In practice, that rules out three very common setups:

• A company adding aggregateRating about itself to its homepage
• A local business marking up its own star rating on its own site
• An organization publishing an Organization review about itself

The reviews themselves aren’t the problem. They’re simply not eligible for review rich results in this situation, which is why the stars don’t appear even when the reviews are entirely genuine. Google’s self-serving reviews rule covers exactly what it bans, what it leaves untouched, and why the distinction exists.

Common Review Schema Violations That Trigger Manual Actions

Not every schema mistake carries the same consequence. Some markup simply gets ignored, while a few specific patterns are what actually trigger a structured data manual action.

The pattern separating the top rows from the bottom rows is intent. A wrong schema type reads as a mistake and gets ignored. Fabricated ratings injected across hundreds of pages read as manipulation, and that’s where a review schema manual action becomes likely.

Manual Actions vs Algorithmic Removal

This distinction explains most of the confusion around disappearing stars, and very few articles spell it out.

Manual action:

• A human reviewer at Google examined your site and applied a spammy structured markup penalty
• You get a notification in the Manual Actions report in Search Console
• Eligibility returns only after you fix the issue and submit a reconsideration request
• A person reads that request, so recovery runs in weeks, not days

Algorithmic removal:

• No human involved, no notification anywhere
• Google’s systems judged the page non-compliant and stopped showing the rich result
• Search Console stays completely clean
• Correcting the markup and waiting for a recrawl is usually enough

The practical takeaway: if your stars vanished and Search Console shows nothing, you’re dealing with algorithmic ineligibility rather than a penalty. That’s the better problem to have. If you’re diagnosing a sudden disappearance, why review stars stop showing often comes down to eligibility, guideline compliance, or a manual action.

One note on severity: a structured data manual action removes rich result eligibility. Google states it doesn’t affect how the page ranks in web search.

Can Valid Review Schema Still Fail to Show Stars?

Yes, and this is the part that frustrates people most. Google states plainly that structured data enables a feature to be present, it does not guarantee it will be present.

Valid review schema markup can still produce nothing when:

• The page type isn’t supported for review rich results
• The markup passes syntax checks but violates a quality guideline the validator can’t test
• Google’s systems have low confidence in the review data
• The site carries weak trust signals overall
• Spam signals exist elsewhere on the domain
• Google’s algorithm determines a plain text result serves the query better

Validation confirms Google can read your markup. It never confirms Google will use it.

How Google Verifies Review Markup: What You Can Check Yourself

Google review markup guidelines come down to a checklist you can run on any page in under five minutes:

• Reviews are visible on the page to a human reader
• Ratings and counts in the markup match what’s displayed
• The schema type is eligible for review rich results
• Reviews come from genuine users, not staff or third-party platforms
• The markup describes one specific item, not a category or list
• All visible reviews are marked up, not a favorable subset
• The Rich Results Test confirms eligibility and no technical errors
• The Schema Markup Validator confirms schema.org conformance, since the two tools check different things
• Search Console rich result reports and the Manual Actions report are both clean

The step no tool performs for you sits in the middle of that list. Open the live page and read it as a stranger would. Every rating value, review count, author name, and date in your JSON-LD should be findable on the rendered page. If you can’t locate it, Google can’t either.

Following review structured data guidelines consistently matters more than getting any single page perfect, because markup drifts. A template change or plugin update can quietly break review schema guidelines compliance across a thousand pages at once. Continuous schema monitoring and automated schema error detection exist because manual auditing stops working somewhere past a few dozen pages.

Conclusion

The short answer to how Google verifies review markup is that it checks the page, not just the code. The markup has to accurately represent visible, trustworthy review content, follow the published guidelines, and stay clear of anything that reads as manipulation.

Meet those conditions and your page can be eligible for the review rich result. Miss them, and no amount of syntactically perfect JSON-LD will close the gap, because the checks that matter most aren’t the ones a validator runs.

If you have review markup live right now, open one of those pages and try to find the reviews with your own eyes. That single test catches more problems than any tool will.

Frequently Asked Questions

Q1: How does Google verify review markup?

Google parses your structured data, then compares it against the rendered page and its published guidelines. Automated systems handle most of this, checking visibility, relevance, and eligibility. Human reviewers get involved when spam signals or reports warrant a closer look.

Q2: Does the review schema need to match visible page content?

Yes. Google requires that the review content you mark up is readily available to users on that page. Reviews that exist only inside your JSON-LD violate the guidelines and are the most common reason valid markup produces no stars.

Q3: Can fake reviews cause manual action?

Yes. Google’s documentation states that ratings not written by actual users may result in a manual action, and it names fake reviews as an example of misleading markup. Fabricated ratings applied across many pages carry the highest risk.

Q4: What are self-serving reviews in Google?

A self-serving review is a review about a business published on that business’s own website, whether added directly in the markup or through an embedded third-party widget. Google stopped showing star ratings for these in 2019.

Q5: Why did Google remove my review stars?

Either a manual action or an algorithmic decision. Check the Manual Actions report in Search Console first. If it’s clean, the cause is algorithmic, usually hidden content, a self-serving review, an ineligible page type, or markup that stopped matching the page.

Q6: How can I make the Review schema eligible for Google rich results?

Display real customer reviews on the page, mark up all of them accurately, use an eligible schema type that describes one specific item, avoid self-serving reviews, validate the markup, and monitor Search Console for issues after each site change.