What Is AggregateRating Schema?
AggregateRating schema is structured data that summarizes the overall rating of a product, service, or item from multiple reviews, expressed as an average score, the rating scale, and the number of reviews or ratings. Added with schema.org's AggregateRating type and usually nested inside a Product, Recipe, or similar item, it can make Google show star ratings in search results, which draws attention and lifts clicks. It condenses many individual reviews into one machine-readable summary that search engines can display at a glance.
- Schema type
- AggregateRating (schema.org)
- Required properties
- ratingValue plus ratingCount or reviewCount (Google Search Central)
- Nested inside
- Product, Recipe, Event, and similar item types (Google Search Central)
- Key restriction
- self-serving LocalBusiness and Organization reviews are not eligible for star rich results (Google Search Central)
What is AggregateRating schema, exactly? #
AggregateRating is a schema.org type that represents the combined rating of an item based on many reviews, rather than a single review. Where a Review object captures one person's opinion, AggregateRating rolls all of them into a summary: an average score, the scale it uses, and how many ratings or reviews contributed. It is almost always nested inside another type, such as a Product or Recipe, because a rating has to be a rating of something. Search engines read this summary and, when the item qualifies, can display a row of star icons beside the listing, sometimes with the numeric average and review count. That visual signal is powerful because it communicates trust before a click. AggregateRating is one of the most sought-after pieces of structured data for exactly that reason, and it fits naturally into the broader structured-data foundation described in our /wiki/schema-markup-guide for any business selling products or services online.
Which properties does AggregateRating need? #
Google requires a small set of properties for AggregateRating to be valid. ratingValue holds the average score, such as 4.7. You must also include at least one of ratingCount, the number of ratings, or reviewCount, the number of written reviews. bestRating and worstRating define the scale; they default to 5 and 1 if omitted, so include them only if you use a different scale. The AggregateRating block sits inside a parent item and should be accompanied, ideally, by the actual individual reviews it summarizes. The example below shows a Product with a nested AggregateRating and one sample review. Keep the numbers honest and matched to what visitors can see on the page, then validate the whole block with /tools/schema-validator. A common failure is providing a ratingValue with no count, or a count of zero, which makes the markup invalid and disqualifies the star display entirely.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Tankless Water Heater Installation Kit",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "128",
"bestRating": "5",
"worstRating": "1"
},
"review": {
"@type": "Review",
"author": { "@type": "Person", "name": "Dana R." },
"reviewRating": { "@type": "Rating", "ratingValue": "5" },
"reviewBody": "Installed cleanly and the crew was on time."
}
}Why does the self-serving review restriction matter? #
This is the single most important thing to understand about AggregateRating, and it catches many businesses off guard. Google does not show review star rich results for self-serving reviews about a LocalBusiness or Organization, meaning reviews you collect and host about your own company. In the past, some sites added AggregateRating to their homepage or LocalBusiness markup to display stars in search, and Google specifically closed that door. Star rich results are supported for items such as products, recipes, books, movies, and software, not for a business reviewing itself. So a dentist cannot mark up their practice with AggregateRating and expect stars, but they could legitimately mark up a specific product they sell. For a local business, review stars in search typically come through your /wiki/google-business-profile-guide and third-party platforms instead. Ignoring this rule wastes development time and risks a manual action, so confirm your use case is allowed before writing any markup.
Where should you use AggregateRating? #
Use AggregateRating on pages about a reviewable item that Google supports and where you genuinely display those reviews. E-commerce product pages are the classic fit: if you run an online store through /services/ecommerce-development, each product with real customer ratings is a strong candidate for star markup. Course pages, software listings, books, and recipes also qualify. The unifying rule is that the ratings must be of the item on the page, collected from real users, and visible on that page. Do not attach AggregateRating to category pages, blog posts, or your business homepage hoping for stars, because those uses either violate the self-serving rule or lack a specific reviewable item. When in doubt, ask two questions: is this a Google-supported reviewable type, and are the reviews actually shown here? If either answer is no, AggregateRating is the wrong tool, and forcing it will do more harm than good to your search presence.
How do you keep rating data accurate? #
AggregateRating must reflect reality, and reality changes as new reviews arrive. Hard-coding a static 4.9 with 200 reviews and never updating it is both misleading and risky, because Google's guidelines require the markup to match visible, current content. The right approach is dynamic: your review system or /wiki/what-is-a-cms should generate the ratingValue and count from actual stored reviews, updating the markup automatically as new ones come in. If you use a review platform, many provide widgets or feeds that output compliant structured data for you. Whatever the source, the number shown in the markup and the number shown on the page to visitors must agree. Inflated or invented ratings are a violation that can lead to a manual action and loss of all rich results. Treat rating data as a live figure tied to a real, auditable source, not a marketing decoration you set once and forget.
How does AggregateRating affect click-through? #
When it displays, an AggregateRating rich result adds a row of gold stars and often a numeric score and review count to your listing. That visual instantly communicates social proof, and results with stars tend to attract more clicks than plain listings at the same position. For a product competing against similar items in search, a strong visible rating can be the deciding factor for a shopper choosing where to click. The uplift comes not from higher ranking, since schema does not boost rank, but from a more persuasive listing. This is why stores invest in genuinely collecting reviews and marking them up correctly, and why a steady flow of new reviews matters more than a single impressive number frozen in time. Once that extra traffic arrives, the product page itself has to convert, which is where /services/conversion-optimization earns its keep. Stars get the click; a clear, trustworthy page turns it into a sale. AggregateRating is best viewed as one link in that chain rather than a standalone win.
What are common AggregateRating mistakes? #
The frequent errors are predictable. Providing a ratingValue with no ratingCount or reviewCount, or a count of zero, invalidates the block. Applying AggregateRating to a self-serving LocalBusiness or Organization, the mistake covered earlier, means Google will never show the stars and may penalize the attempt. Mismatched numbers, where the markup claims more reviews than the page actually displays, violate guidelines. Marking up an unsupported item type wastes effort because no rich result exists for it. Some sites also nest AggregateRating incorrectly, floating it without a valid parent item. Finally, inventing ratings outright is the most serious violation and can trigger a manual action affecting the whole site. Run every implementation through Google's Rich Results Test and /tools/schema-validator, and monitor Search Console's enhancement reports afterward. Most problems are caught in minutes at validation time, long before they cost you a rich result or a penalty in live search.
How do you implement and test AggregateRating? #
Start by confirming your use case is legitimate: a supported reviewable item, with real reviews visible on the page, not a self-serving business rating. Next, wire the ratingValue and count to your actual review data so the markup updates automatically. Generate consistent JSON-LD, ideally with /tools/schema-generator, and nest the AggregateRating inside the correct parent type. Validate the output with Google's Rich Results Test and /tools/schema-validator, fixing any errors before publishing. After launch, watch Search Console's Review snippet report for eligibility and issues at scale. Re-check after any redesign or /services/website-migrations project, since template changes can drop the nested markup without warning. For businesses that lack in-house developers or run large catalogs, an ongoing /services/care-plans arrangement keeps rating markup accurate as reviews accumulate and the site evolves. Done right, AggregateRating turns the reviews you already collect into a visible, trust-building feature in search results.
FAQ
Why won't Google show stars for my business homepage?
Because Google does not display review star rich results for self-serving reviews about a LocalBusiness or Organization, meaning reviews you host about your own company. Stars are supported for items like products and recipes, not a business rating itself. For local businesses, review stars in search typically come through your Google Business Profile and third-party review platforms instead.
What is the difference between Review and AggregateRating?
A Review object captures one individual review with an author, a rating, and review text. AggregateRating summarizes many reviews into a single average score plus a count. They often appear together: AggregateRating gives the overall picture, while individual Review objects provide the underlying detail. Google's guidelines encourage including both when you display real reviews on a page.
Do I need both ratingCount and reviewCount?
No. You must include at least one of them, but not necessarily both. ratingCount counts all ratings, including those without written text, while reviewCount counts written reviews specifically. Use whichever accurately describes your data, and if you have both types, you can include both. Providing neither makes the AggregateRating invalid and disqualifies the star display.
Can I make up review numbers to get stars?
No, and doing so is a serious violation. Google requires markup to match real, visible reviews on the page. Inventing or inflating ratings can trigger a manual action that removes rich results and harms your entire site's search presence. Always tie the ratingValue and count to a genuine, auditable source of customer reviews you actually display.
Where does AggregateRating fit on an e-commerce site?
On individual product pages that have genuine customer ratings displayed. Each product with real reviews is a strong candidate for star markup, which can lift click-through in search. If you run a store built through /services/ecommerce-development, wire the ratings to your review data so they update automatically, and validate the markup before publishing across the catalog.
How do I test whether my rating markup works?
Run the page through Google's Rich Results Test to check eligibility and our /tools/schema-validator for syntax against schema.org. After publishing, monitor Search Console's Review snippet enhancement report for site-wide status and errors. Together these confirm what Google can read, whether the item qualifies for stars, and what needs fixing before the feature can appear.
Was this helpful?