What Is Review Schema?
Review schema is structured data from schema.org that marks up a rating and opinion about a business, product, or service so search engines can understand and display it. Added as JSON-LD, a single review names the author, the rating value, and the item reviewed, while AggregateRating summarizes many reviews into an average and count. Google can render this as gold star ratings beneath a listing, which increases visibility and click-through when applied to eligible content honestly.
- Vocabulary
- schema.org/Review and schema.org/AggregateRating (schema.org)
- Star rating scale
- Default 1 to 5; bestRating and worstRating can be set (schema.org)
- Self-serving rule
- Ratings a business writes about itself are not eligible for stars (Google Search Central)
- Must be visible
- Reviews and ratings must appear on the same page as the markup (Google Search Central)
What is Review schema and what does it produce? #
Review schema is the code that tells a search engine, someone rated this item this many stars and here is what they said. It comes in two flavors. A single Review names the author, the reviewRating with its value, and the itemReviewed, whether that is a product, a service, a local business, or an organization. AggregateRating rolls up many reviews into a single average ratingValue and a reviewCount or ratingCount. When Google reads valid review markup on eligible content, it can display gold star ratings in the search result, one of the most attention-grabbing enhancements available, because stars stand out visually and signal social proof before a click. Review schema is part of the schema.org system covered in /wiki/schema-markup-guide, and it frequently combines with Product, LocalBusiness, and Service markup to attach ratings to the right entity. Used honestly, it is a powerful way to make a listing more clickable; used carelessly, it is one of the easier ways to earn a manual penalty.
What are Google's strict eligibility rules? #
Google enforces review markup more strictly than most schema types because it is widely abused. The central rule is that ratings must not be self-serving. You cannot mark up a review your own business wrote about itself and expect stars; that is explicitly disallowed. The reviews must be genuine, and they must be visible on the same page as the markup, so a customer can read the actual review that produces the star rating. You cannot aggregate ratings pulled invisibly from third-party sites and display stars your own page does not show. You cannot mark up ratings for the entire website on a single page; the review must attach to a specific item. Violating these rules can remove all your rich results and, in serious cases, trigger a manual action. Google's structured-data policies, referenced in Google Search Central, spell this out. The safe path is simple: display real customer reviews on the page, then mark up exactly what is visible, generating the code with /tools/schema-generator.
What does Review and AggregateRating JSON-LD look like? #
There are two patterns. A single review attaches an author and a reviewRating to an itemReviewed. An aggregate rating attaches a summary directly to the item, such as a Product or LocalBusiness. The example below shows an AggregateRating nested inside a Product, which is the most common ecommerce pattern, plus a sample individual review. Note reviewRating uses ratingValue on a 1 to 5 scale by default, and you can set bestRating explicitly. The reviewCount must reflect the number of reviews actually shown. Never invent counts or values. After deploying, watch Google Search Console's Review snippet report for warnings, and validate with /tools/schema-validator. A frequent error is placing AggregateRating with a count of reviews that do not appear on the page, which Google flags. Keep the markup honest and tied to visible content, and the stars follow.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Stainless Steel Water Bottle 24oz",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "128",
"bestRating": "5"
},
"review": [
{
"@type": "Review",
"author": { "@type": "Person", "name": "Dana R." },
"datePublished": "2026-05-14",
"reviewRating": {
"@type": "Rating",
"ratingValue": "5",
"bestRating": "5"
},
"reviewBody": "Keeps my water cold all day. Exactly as described."
}
]
}Why can't I mark up my own testimonials for stars? #
This is the most common misunderstanding. Businesses collect glowing testimonials, put them on a testimonials page, mark them up with Review schema, and expect gold stars, then wonder why they never appear. Google's self-serving rule blocks exactly this: a rating that the business itself provides about its own entity is not eligible for a star rich result. The rationale is trust; if any business could award itself five stars in markup, the stars would be meaningless. Genuine third-party reviews shown on the page can be eligible, and product reviews written by customers are eligible, but a company grading itself is not. This does not mean testimonials are useless; they still build trust with human readers and support conversions, which our /services/conversion-optimization work leverages. It simply means you should not expect them to produce search stars. To earn star visibility for a local business, the more reliable path is accumulating reviews on your Google Business Profile, covered in /google-business-profile-guide, which Google displays through its own systems.
How do local businesses actually get star ratings in search? #
For a plumber, dentist, or restaurant, the star ratings people see in Google usually come from the Google Business Profile and the Map Pack, not from Review schema on the website. Google aggregates reviews left directly on your profile and shows that average in local results and the knowledge panel. That is why our /services/local-seo work prioritizes a steady flow of genuine Google reviews, supported by tools like /tools/review-link-generator that make it one tap for a happy customer to leave feedback. Review schema on your own site still has a role, attaching ratings to specific products you sell or corroborating your reputation for AI systems, but it is not the primary route to local stars. Understanding this distinction saves a lot of wasted effort. Rather than trying to engineer stars through self-written markup, focus on earning real reviews on the platforms Google trusts, then use schema honestly where third-party or product reviews genuinely appear on your pages.
How does Review schema interact with other markup? #
Review and AggregateRating rarely stand alone; they attach to a parent entity. On a product page, they nest inside Product to produce shopping stars, as covered in /wiki/what-is-product-schema. On a local business page, they can attach to LocalBusiness. On a service page, they can attach to Service, described in /wiki/what-is-service-schema. The itemReviewed property, or the position of the rating inside the parent object, tells Google what the rating is about. Getting this attachment right matters: a rating floating without a clear subject is ambiguous and may be ignored. When you combine markup, keep the whole graph consistent, the product name in the Product object should match the name in any review that references it. Our /wiki/schema-markup-guide covers how these types fit together into a coherent structured-data strategy. The practical takeaway is to decide first what entity the reviews describe, then nest or reference the rating from that entity, rather than dropping isolated Review blocks onto a page.
What are the risks and penalties of misuse? #
Review markup is a frequent target of Google's spam enforcement precisely because stars are valuable and tempting to fake. The risks are real. Marking up invented ratings, aggregating reviews the page does not display, using self-serving testimonials for stars, or applying ratings to the whole site instead of a specific item can all trigger a manual action under the structured-data spam policy. A manual action can strip every rich result from your site and is tedious to reverse. Even short of a penalty, Google may simply ignore markup it does not trust, so the dishonest effort yields nothing. The defensive posture is straightforward: only mark up real reviews that a visitor can see on the page, attach ratings to specific items, keep counts truthful, and validate everything with /tools/schema-validator before deploying. If you inherited a site with dodgy review markup, our /services/website-rescue team audits and removes it before it causes damage, replacing it with honest structured data that actually helps.
How do you implement and maintain Review schema? #
Start by deciding where genuine reviews live and what they describe. For products, wire the AggregateRating into the product template so it draws from the same review data shown on the page, which our /services/ecommerce-development team builds in. For local reputation, invest in Google reviews through /services/local-seo rather than site markup. Where you do display third-party or customer reviews on your pages, generate the markup with /tools/schema-generator, keep the values tied to the visible content through a single data source, and validate before launch. Maintenance means keeping counts and averages current as new reviews arrive; a stale reviewCount of 12 on a product with 200 reviews undersells you and, if the visible page shows 200, mismatches the schema. Automate the update so it tracks the live data. Monitor Google Search Console for review snippet warnings, and re-validate after any template change. Handled this way, Review schema becomes a durable, honest asset rather than a compliance risk, and it is part of the structured-data care we provide under /services/care-plans.
FAQ
Why don't my testimonials show star ratings in Google?
Because Google's self-serving rule blocks ratings a business provides about itself. Testimonials you collect and mark up on your own site are not eligible for star rich results, no matter how genuine. Testimonials still build trust with human readers, but for search stars you need genuine third-party or product reviews, or reviews on your Google Business Profile.
How do local businesses get gold stars in search results?
Usually through the Google Business Profile, not website schema. Google aggregates reviews left directly on your profile and displays that average in local results and the knowledge panel. Building a steady flow of real Google reviews, made easy with a review link generator, is the reliable path to local stars, which is why local SEO prioritizes it over site markup.
What is the difference between Review and AggregateRating?
A Review is a single opinion with one author and one rating. AggregateRating summarizes many reviews into an average ratingValue and a total count. Product and business pages typically use AggregateRating to show an overall score, and may also list individual reviews. Both must reflect reviews genuinely visible on the page.
Can I get penalized for review schema?
Yes. Marking up invented ratings, aggregating reviews the page does not display, using self-serving testimonials for stars, or rating the whole site can trigger a manual action that strips your rich results. Only mark up real, visible reviews attached to a specific item, keep counts truthful, and validate before deploying to stay safe.
Does the rating have to be out of five stars?
Five is the default scale, but you can set bestRating and worstRating to use a different range, such as 1 to 10. Google normalizes the display to five stars regardless. Whatever scale you use, the ratingValue must fall within it and must reflect the reviews actually shown on the page.
What should my review markup attach to?
It should attach to a specific entity, a Product, LocalBusiness, Service, or Organization, using the itemReviewed property or by nesting the rating inside that entity. A rating with no clear subject is ambiguous and often ignored. Decide what the reviews describe first, then reference the rating from that entity for a coherent structured-data graph.
Was this helpful?