Review vs AggregateRating Schema: Differences, Use Cases, Examples, and Best Practices

If you’ve ever run a page through a validator and hit the error “review or aggregateRating should be specified,” you’ve met one of the most common points of confusion in structured data. Both properties deal with ratings. Both can produce star-rating rich results. Yet they describe two very different things, and mixing them up is a frequent reason review snippets never appear.

The consequence isn’t small. Star ratings are one of the most visible SERP enhancements available, and Google’s own case studies show what correct structured data can do. Rotten Tomatoes measured a 25% higher click-through rate on pages with markup, while Food Network saw a 35% increase in visits after enabling search features across its site. Getting the review vs AggregateRating schema decision right is what makes that kind of visibility possible.

In this article, we’ll break down what each type does, when to use which, how to combine them, and the implementation mistakes that quietly disqualify pages from review snippets.

Review vs AggregateRating Schema: Quick Comparison

Although both schema types relate to ratings, they serve different purposes in structured data. This quick comparison highlights the key differences before we explore each schema type in more detail.

Review vs AggregateRating Schema: Key Differences

In simple terms, Review structured data answers “what did this person think?” while AggregateRating structured data answers “what does everyone think on average?”

As per the official schema.org/Review and schema.org/AggregateRating definitions, a Review carries an author, a reviewRating, and often a reviewBody. An AggregateRating carries a ratingValue calculated across multiple reviews, along with the count behind it.

Here’s why this matters: Google treats these as related but distinct inputs for the review snippet feature. Google states that for aggregate ratings, the average score must be supplied for stars to display, and that both types should be nested into a parent schema.org type rather than floating on their own.

When Should You Use a Review Schema?

Use review schema markup when a page contains one or more individual, genuine evaluations, a customer review on a product page, a critic’s assessment of a book, or an editorial review of a recipe or service.

A valid Review needs a clear item being reviewed, an author, and a rating (or an author plus review date). The review content must also be visible on the page, marking up reviews users can’t see violates Google’s guidelines.

{
"@context": "https://schema.org",
"@type": "Product",
"name": "Trailhead Running Shoes",
"review": {
"@type": "Review",
"author": { "@type": "Person", "name": "Dana M." },
"reviewRating": { "@type": "Rating", "ratingValue": "5", "bestRating": "5" },
"reviewBody": "Light, supportive, and held up well after 200 miles."
}
}

The key point is authenticity. Reviews must come from real customers or independent critics, not from the site owner, staff, or fabricated testimonials. That distinction sits at the heart of what makes review structured data trustworthy to search engines.

When Should You Use AggregateRating Schema?

Use AggregateRating schema when you have multiple ratings for the same item and want to present the average. This is the markup behind the familiar “4.7 stars (312 reviews)” display in search results.

AggregateRating schema markup requires a ratingValue plus at least one of ratingCount or reviewCount. If your scale isn’t 1-5, declare bestRating and worstRating explicitly.

{
"@context": "https://schema.org",
"@type": "Product",
"name": "Trailhead Running Shoes",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "312",
"bestRating": "5"
}
}

A common issue is publishing an aggregate score that doesn’t match what’s visible on the page, or counting ratings that live only on a third-party platform. The numbers in your aggregate rating structured data should reflect real, on-page (or clearly accessible) ratings, and update as new reviews arrive.

If your ratings change frequently, continuous schema monitoring helps catch drift between your markup and your actual review data before Google does.

Can You Use Review and AggregateRating Together?

Yes, and in most cases, you should. Google explicitly supports nesting both a review array and an aggregateRating object inside the same parent type. This gives search engines the full picture: individual voices plus the overall consensus.

{
"@context": "https://schema.org",
"@type": "Product",
"name": "Trailhead Running Shoes",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "312"
},
"review": [{
"@type": "Review",
"author": { "@type": "Person", "name": "Dana M." },
"reviewRating": { "@type": "Rating", "ratingValue": "5" }
}]
}

This combined pattern is standard practice on eCommerce product pages, where it pairs naturally with product schema markup that already includes offers, pricing, and availability.

Review vs AggregateRating Schema: At a Glance

Choosing the right schema depends on the type of review information your page contains. Use the table below to quickly determine whether Review, AggregateRating, or both are the best fit for your content.

Best Practices That Keep You Eligible for Review Snippets

Implementing Review or AggregateRating schema correctly is only part of the process. Following Google’s structured data guidelines and keeping your markup accurate, visible, and up to date gives your pages the best chance of qualifying for review snippets.

Nest inside a supported parent type

Google supports review snippets for types like Product, Recipe, Book, Movie, Course, and Local Business, but not every schema type is eligible for review stars. Always attach your review or rating to a specific item, never to the page in general.

Avoid self-serving reviews

Since Google’s 2019 update, pages using LocalBusiness or Organization schema are ineligible for star ratings when the entity controls its own reviews. Product reviews collected on your own product pages remain fine, the restriction targets businesses rating themselves.

Match markup to visible content

The rating in your structured data must equal the rating users see. Mismatches erode trust and eligibility.

Validate before and after publishing

Run every page through the Rich Results Test, fix errors first, then review warnings.

Keep it consistent at scale

Manually maintaining ratings across hundreds of pages is where most implementations break down. If you’re new to how schema markup works, start with one template page, validate it, then scale. A tool like JSON Schema App can generate and update reviews and AggregateRating JSON-LD dynamically, so counts and averages stay accurate as reviews come in.

Conclusion

The review vs AggregateRating schema question comes down to scope: one review versus the sum of many. Use Review schema for genuine individual evaluations, AggregateRating schema when you have multiple ratings to average, and nest both inside a specific parent type for the most complete review snippet schema.

From there, eligibility is about discipline, accurate numbers, visible content, no self-serving markup, and validation on every page. Run your key product or service pages through the Rich Results Test this week, and if maintaining accurate ratings across many pages is the key, automating your JSON-LD is the practical next step.

FAQs

Q1: What is the main difference between Review and AggregateRating schema?

Review schema describes a single evaluation from one author; AggregateRating schema describes the average score across many ratings, with a required count. One is an individual opinion, the other is a summary.

Q2: Can AggregateRating exist without individual Review markup?

Yes. Google only requires one of the two for review snippet eligibility. That said, the underlying ratings must be real and visible to users, an aggregate score with no accessible reviews is a red flag.

Q3: Why aren’t my star ratings showing in Google?

Common causes include missing required properties (like ratingValue or reviewCount), self-serving reviews on LocalBusiness or Organization pages, markup that doesn’t match visible content, or an unsupported parent type. Rich results are also never guaranteed, Google decides display case by case.

Q4: Does review schema directly improve rankings?

No. Review structured data influences how your listing appears, not where it ranks. The visibility benefit comes from enhanced presentation, stars and counts that can improve click-through rates.

Q5: Which parent types support review snippets?

Google lists types including Product, Recipe, Book, Movie, Course, Event, Software App, and Local Business (with the self-serving restriction). Attach your markup to the most specific applicable type.

Q6: Should reviewCount include ratings without written reviews?

Use reviewCount for written reviews and ratingCount for all ratings, including star-only ones. Pick the property that matches your data source and stay consistent.