AggregateRating schema markup is the structured data type that powers those star-rating displays in Google search results — the ones that show “4.6 stars (214 reviews)” directly under a listing before a user ever clicks. It represents a rolled-up score: the average of many individual ratings rather than one reviewer’s opinion. Aggregate rating schema markup is almost always nested inside another entity rather than standing alone, and it has a set of policy requirements that are easy to get wrong if you treat it as a cosmetic addition rather than a data integrity commitment. After 14 years of implementing this for clients, the most common issue I find is stale or manufactured rating data — both of which cost you rich result eligibility.

What is AggregateRating schema markup?

The schema.org/AggregateRating type communicates a computed average score to search engines: the numeric rating, the scale it was measured on, and how many ratings or reviews contributed to that average. It is used as a nested property inside a parent entity — Product, LocalBusiness, Course, Recipe, Book, Movie, SoftwareApplication, or other eligible types — to tell Google the collective opinion of real users. When Google validates and trusts the data, it can display those stars and review counts in search results as a rich result. This is not a ranking factor. It is a rich result eligibility signal. The visual differentiation it creates — stars in the SERP — has a measurable impact on click-through rate for the pages that earn it.

Which pages and entity types can use AggregateRating?

Google supports AggregateRating rich results for a defined set of content types. Using it on an entity type outside that list will produce valid JSON-LD that Google simply ignores for rich result purposes. The supported types as of mid-2026: Book, Course, Event, HowTo, LocalBusiness, Movie, Product, Recipe, and SoftwareApplication. A few practical points: an Organization rating itself does not qualify. A service page on a B2B site trying to display aggregate ratings for consulting services does not qualify under the Service type. If the entity type is not in Google’s supported list, the stars will not appear regardless of how clean the markup is. Check the official structured data documentation before assuming your entity type qualifies — I have seen clients spend time implementing this on pages that are structurally ineligible.

Required and recommended properties

  • ratingValue (required) — the computed average rating as a number or string; must match what is displayed on the page
  • reviewCount or ratingCount (required — at least one) — the total number of reviews or ratings contributing to the average
  • bestRating (recommended) — the maximum value on your scale; defaults to 5 if omitted, but explicit is always better
  • worstRating (recommended) — the minimum value on your scale; defaults to 1 if omitted
  • itemReviewed (required when used as standalone) — the entity the aggregate rating describes; when nested inside a Product or LocalBusiness, this is implied by the parent object

How to implement AggregateRating in JSON-LD

The standard approach is to nest aggregateRating inside the parent entity’s JSON-LD block. Here is a working example for a product page with a dynamically-sourced aggregate rating:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Standing Desk Frame — Adjustable Height",
  "image": "https://example.com/images/standing-desk.jpg",
  "brand": {
    "@type": "Brand",
    "name": "ErgoCore"
  },
  "offers": {
    "@type": "Offer",
    "price": "499.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "priceValidUntil": "2026-12-31"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "214",
    "ratingCount": "231",
    "bestRating": "5",
    "worstRating": "1"
  }
}

Step-by-step: (1) Build the parent entity object — Product, LocalBusiness, Recipe, etc. (2) Add aggregateRating as a property of that parent. (3) Set ratingValue to the current average, drawn from your review system. (4) Set reviewCount to the number of written reviews, ratingCount to the number of ratings. (5) Explicitly set bestRating and worstRating. (6) Validate with the Rich Results Test. (7) Wire the values to live data so they update automatically when new reviews come in. For more on the mechanics of adding this to a WordPress site, see my guide on how to add schema markup.

ratingCount vs. reviewCount: the property that trips everyone up

This is the most common confusion I see in aggregate rating implementations, and it has a concrete consequence if you get it wrong. reviewCount means the number of written reviews — a customer clicked five stars AND wrote text. ratingCount means the total number of ratings, including people who clicked stars but wrote nothing. If your e-commerce platform shows “214 reviews” and “231 ratings” separately, use both properties as shown above. If you only have star clicks without review text, use ratingCount — not reviewCount. Using reviewCount when customers only rated without writing implies more depth of feedback than actually exists, which can trigger a data quality flag. The distinction matters especially if Google cross-references your structured data against the visible review content on the page and finds a count mismatch.

The same logic applies to the ratingValue: it must match the average visible on the page. If your review widget shows 4.6 and your JSON-LD says 4.8, that is a structured data mismatch — one of the fastest ways to lose rich result eligibility. For a broader look at product schema markup that includes AggregateRating in context, that post covers the full property set for e-commerce pages.

How to test AggregateRating schema markup

Use Google’s Rich Results Test first — it will show whether the AggregateRating type was detected inside your parent entity, flag any missing required properties, and preview what the rich result would look like. Pay specific attention to whether ratingValue, reviewCount or ratingCount, and bestRating all appear in the detected properties. If any are missing, the rich result preview will be absent. For lower-level structural validation, run the markup through the Schema Markup Validator to catch type-level errors. After publishing, monitor the Enhancements section of Google Search Console for coverage errors — specifically look for “missing field ratingValue” or “invalid value for ratingCount” errors, which are the most common flags I see in audits. My full testing guide is at how to test schema markup.

How aggregate ratings appear in AI search and AI Overviews

AI Overviews increasingly synthesize product and service opinions from across the web, and structured aggregate rating data is one of the cleaner signals those systems can read. When a user asks “what do people think of X product,” Google’s AI systems pull from sources where the rating data is explicit and machine-readable rather than buried in prose. A page with valid, up-to-date AggregateRating markup — matched to real on-page review content — is more likely to have its rating represented accurately in AI-generated summaries than a page that lists reviews in unstructured text. This is not a guarantee of inclusion; it is a clarity advantage. The same principle applies to voice search surfaces, where an AI reading a rating aloud needs the value to be unambiguous. Clean structured data reduces the chance that a 4-out-of-5 rating is misread as 4-out-of-10 because bestRating was omitted. For a broader look at this, see my article on structured data for SEO.

AggregateRating is simple to implement but requires data discipline to maintain. If your current markup is not generating rich results, or if you are getting coverage errors in Search Console, a schema audit will pinpoint whether the issue is structural or a policy flag. For the individual review markup that feeds into aggregate scores, see review schema markup. And if you want a hands-on review of your full structured data strategy, reach out through my schema markup consulting page.