Star ratings can catch attention in Google results, but they aren’t something a local business can turn on with a few lines of schema markup. Eligibility depends on accurate schema markup built with the schema.org vocabulary. Review snippet schema has strict eligibility rules, and Google may choose not to show a review snippet even when the markup is valid.
That matters because many businesses add ratings from their own testimonials or Google Business Profile widgets, then expect stars in organic search. Stars may affect how a result is noticed, but they don’t guarantee a higher click-through rate or more organic traffic. A page may pass a validator and still be ineligible.
Here is what to use, what to avoid, and how to check your setup before assuming valid markup will produce a rich result.
Key Takeaways
- Review schema must describe real, visible, user-supplied content on the page.
- A local business generally cannot mark up reviews about itself and qualify for Google review stars in standard organic results.
- Google Business Profile reviews are valuable for Maps and local trust, but embedding them on your site does not bypass the self-serving review rule.
- Individual
Reviewmarkup and aggregate ratings do different jobs. - Valid structured data is not a promise that Google will display a rich result.
- Test the live page, not only the code inside a plugin or CMS field.
How Review Snippet Schema Can Appear in Google
Review snippet schema is structured data that helps Google understand a rating or individual review. When a page qualifies, Google may show star ratings, reviewer details, or rating counts below an organic result.
That extra information can make a listing easier to scan through rich snippets. It may affect click-through rate, but markup isn’t an ad format. Google controls when, where, and whether the feature appears.
Individual reviews describe one person’s experience
A Review item is about one review from one person. It can include the review author, the rating, the item being reviewed, and the published date.
For example, a product page may show a customer’s written feedback about a specific item. The page’s markup can describe that same review. The page content and the schema must tell the same story.
Google’s review snippet documentation identifies author, the item reviewed, identified by itemReviewed, and reviewRating as core details. The ratingValue inside reviewRating is also required for review-snippet eligibility.
Aggregate ratings combine many reviews
An AggregateRating is the combined score for an item. It can show a rating value along with a review count or rating count.
Think of it like the average at the top of a product’s review section. A 4.7 rating based on 86 reviews is an aggregate rating. It isn’t the same thing as a single customer’s review.
| Markup type | What it describes | Common use |
|---|---|---|
Review | One person’s review and rating | A visible product review |
AggregateRating | A combined score across ratings or reviews | A visible product rating summary |
Review and AggregateRating are distinct schema.org types. Use the type that matches the page. Don’t add both because it looks more complete. More markup isn’t better when it doesn’t match the content.
Local Businesses Face a Self-Serving Review Restriction
This is the rule that catches most local businesses. Under current Google guidelines, Google doesn’t allow a business to use review schema for testimonials about itself when it controls the page.
That restriction applies to LocalBusiness and Organization pages. A plumber, dentist, restaurant, law firm, HVAC company, or salon can’t add its own customer testimonials to its homepage schema and expect organic-result stars.
Testimonials can still help people decide
This rule doesn’t make testimonials useless. Authentic, permission-based customer reviews on service pages, location pages, and case studies can still build confidence with visitors.
Use reviews to show what customers appreciated. Mention the real service, location, or outcome when the customer gave permission. Keep the wording accurate, and don’t edit reviews until they say something different.
Reviews also help you understand what people value. Fast communication, clean work, clear pricing, easy scheduling, and friendly staff are details future customers care about.
A visible five-star testimonial can help a visitor choose your business, even when Google doesn’t display review stars beside your organic listing.
Google Business Profile reviews are separate
Your Google Business Profile is still important. Its reviews can influence how people view your company in Google Maps and local search features. They aren’t the same as review snippet schema on your website.
Embedding a Google or Facebook review widget doesn’t make a self-controlled local business page eligible for review stars. The business still controls the page where the widget appears.
Keep asking satisfied customers for honest feedback after a completed service. Then reply with care. Our Google Business Profile SEO guide can help you keep that profile complete, active, and useful for local customers.
Review Snippet Schema Properties That Matter
Schema markup needs enough detail for search engines to identify what the page shows. The supported properties come from schema.org, and they depend on whether the type is Review or AggregateRating.
Start with the page itself. If people can’t see the rating or review, it shouldn’t appear in the markup. The same consistency rule applies whether you use JSON-LD or microdata.
Required details for an individual review
A qualifying Review setup needs an author, itemReviewed, and reviewRating. The rating value belongs in ratingValue.
Other fields add helpful context. datePublished tells Google when the review appeared. bestRating and worstRating clarify the rating scale when it isn’t obvious.
A five-point scale should be visible to users if you mark it up that way. Don’t show 4.5 out of 5 on the page, then send a different scale in JSON-LD.
Supporting details for aggregate ratings
For an aggregate rating, the central fields are the overall rating and the number of reviews or ratings behind it. Use reviewCount for the review count when you’re counting written reviews. Use ratingCount for the rating count when the total includes ratings without written feedback.
The numbers must match what visitors can see. If your product page says “4.8 from 24 reviews,” the structured data can’t claim 4.9 from 125 ratings.
Google’s broader structured-data guidance follows the same common-sense rule: markup should accurately describe the page Google can access.
Put Review Markup on the Right Page Type
LocalBusiness schema explains your business name, phone number, hours, address, and service area. It isn’t a shortcut to self-serving review stars.
Review markup describes individual feedback, while AggregateRating summarizes aggregate ratings. Product and LocalBusiness are distinct schema.org types, with different purposes and eligibility rules.
We recommend treating business details and reviews as two separate jobs. One helps search engines understand your company. The other describes eligible review content when the page type and Google rules allow it.
Product pages are a common eligible use
A local retailer can use Product markup for an individual product page with real, visible customer reviews. Product schema is appropriate when those reviews apply to the specific product, not the retailer.
Whether you use JSON-LD or microdata, the page still needs visible, product-specific review content. The rating must apply to that product, not to the store as a whole.
For example, a garden center could show reviews for a specific cordless mower it sells. It shouldn’t attach the store’s overall Google review score to every mower, mulch, or patio set page.
The product page needs clear product information, visible reviews, and ratings that update when the page changes. Keeping ratings, prices, and inventory current is a practical ecommerce seo task, not a promise of rankings.
Location pages need honest business details
Multi-location companies should give each real location its own accurate page. That page can use LocalBusiness schema for branch details, but it shouldn’t claim reviews for the company itself through self-serving markup.
A location page should match its linked Google Business Profile. Use the same business name format, address, phone number, hours, and service scope. Our location page SEO best practices explain how to keep those local signals aligned.
Service-area businesses shouldn’t invent addresses or create pretend offices in every city. Clear service-area copy is better than a fake location.
Add JSON-LD and Check the Rendered Page
JSON-LD is usually the easiest format for publishing structured data markup because it expresses schema.org vocabulary in one block. Unlike inline microdata, it keeps structured data separate from the visible page markup.
The code can load in the page head or body. What matters is that Google can access it in the final rendered HTML.
Keep one clear source of markup
Themes, plugins, ecommerce apps, and tag managers can all generate schema. That becomes a problem when two tools describe the same product or business with different ratings.
We prefer one clean source of review markup per page type. Check the rendered source after publishing. Don’t assume a plugin setting means the code reached the live page.
Watch for these common problems:
- A plugin outputs an old aggregate rating after the visible review count changed.
- A widget loads reviews in the browser, but Google can’t access the structured data.
- A hardcoded JSON-LD block conflicts with schema generated by WooCommerce, Shopify, or an SEO plugin.
- The same rating is copied across unrelated service, city, and product pages.
Validate before and after launch
First, test the public URL with Google’s Rich Results Test. It shows which rich-result types Google may be able to generate from the page and flags critical errors. Passing validation doesn’t guarantee that Google will display a rich result.
Then check the live page on desktop and mobile. Confirm the review text, rating value, and review count are visible to users. If your site uses JavaScript, check the rendered page rather than relying on a CMS preview.
Finally, monitor the Google Search Console Rich Results Report after Google crawls the page. URL-level testing checks one page, while this report can reveal errors across multiple URLs.
Troubleshoot Review Schema Problems in Order
A failed rich result is not always a code problem. It may be a mismatch, an indexing issue, duplicate markup, or a page that isn’t eligible for review snippets.
Work through the basics before changing every field in the schema.
Start with visible content and eligibility
Compare the live page to the markup line by line. Check that the declared type and properties match the intended schema.org vocabulary. Does the page visibly show the same review text, star rating, review count, and item name? Is the review genuine and supplied by a customer?
Next, ask whether the page is self-serving. If it’s your own LocalBusiness or Organization page showing reviews about your business, Google review stars aren’t available for that page. A schema validator can identify syntax or parsing issues, but it can’t override that policy.
This is where many businesses waste time. The code may be technically valid, but the feature isn’t available for that use.
Check indexing, duplication, and updates
A page that’s blocked, noindexed, or not indexed can’t earn a search feature. Use the Rich Results Test to check eligibility, then use Google Search Console to review indexing status and crawl issues.
Also inspect every schema source, including inline microdata and generated JSON-LD. Search the rendered page for AggregateRating, Review, and ratingValue. Duplicate blocks with conflicting values can confuse parsers and create warnings.
Review schema needs regular maintenance. When reviews change, pages are redesigned, or a location closes, update both the visible content and the markup. Our local SEO audit checklist is a practical way to catch old hours, outdated phone numbers, and review inconsistencies.
FAQ
Can a local business add its Google reviews to schema markup?
A local business can display Google Business Profile reviews on its website when it follows the platform’s terms and accurately shows the content. However, putting those reviews into LocalBusiness or Organization markup does not make the business eligible for Google review stars in organic results.
Google treats this as self-serving review markup because the business controls the page.
Does valid review schema guarantee star ratings in search?
No. Passing the Rich Results Test means Google can parse the markup and may generate an eligible rich-result type. For eligible product content, Google still decides whether to show the feature for a particular search.
Search results can change by query, device, location, page quality, and Google’s own presentation choices.
Should every service page have aggregate rating markup?
No. A service page should only include review or aggregate rating markup when its visible review count and rating genuinely describe that page’s content. Copying one business-wide rating across every service page creates a mismatch and can create policy problems.
Use LocalBusiness structured data for business facts, and keep reviews visible for people even when stars are not eligible.
Final Thoughts
Review snippet schema works best as a factual label, not a way to force star ratings into Google results or guarantee organic traffic or a higher click-through rate. Google may omit rich results even when the implementation is valid. For local businesses, the biggest rule is simple: do not mark up self-serving reviews about your own company.
Keep your business details accurate, publish real customer feedback for visitors, and use review markup only where the page and Google’s eligibility rules support it. Maintain visible content and compliant data, remembering that valid schema doesn’t determine whether Google displays a search feature.
