AggregateRating Schema for AI Citations

TL;DR

Use AggregateRating whenever a page shows an overall star rating or numeric score computed from multiple reviews. Set ratingValue (the average), one of reviewCount (text reviews) or ratingCount (numeric ratings only), and clarify scale with bestRating and worstRating whenever it is not the default 1-5. Attach the AggregateRating to exactly one parent (Product, Course, SoftwareApplication, LocalBusiness, etc.) via itemReviewed or by nesting; never reuse the same rating across two different itemReviewed targets, per Google's November 2025 review-snippet clarification (Search Engine Journal, 2025). When a page has zero reviews, omit the AggregateRating block entirely — do not emit ratingValue: 0 or an empty string.

What AggregateRating is for

AggregateRating sits on the schema.org tree as Thing > Intangible > StructuredValue > Rating > AggregateRating (schema.org/AggregateRating). It models the overall rating of an item based on multiple reviews — distinct from individual Review markup, which captures one reviewer's verdict.

The parent-type list on schema.org is broad: Brand, CreativeWork, Event, Offer, Organization, Place, Product, Service. Google's review-snippet documentation, however, restricts which parents are eligible for the rich star result to a specific set: Book, Course list, Event, Local business, Movie, Product, Recipe, and Software App (Google Search Central, review snippet). Outside that list, the markup is still valid and still readable by AI engines, but it will not produce stars in Google Search.

AI engines treat AggregateRating as a fact-checkable claim. ChatGPT search and Perplexity will sometimes cite "4.6 stars across 5,200 reviews" verbatim from the structured data, and they cross-check the figure against the visible page. Markup that contradicts the visible content is treated as an integrity signal against the source.

Properties — required, recommended, and inherited

AggregateRating defines five direct properties; it inherits the rating-scale fields from Rating (schema.org/AggregateRating):

Four practical rules apply across consumers:

1. Set ratingValue as a number, not a string when possible (4.5 not "4.5"). Most validators accept both, but AI extractors quote the raw form.
2. Use reviewCount for text-bearing reviews and ratingCount for numeric-only star clicks. Pages that mix the two should expose both; pages with only one type should expose only that one.
3. Set bestRating explicitly when it is not 5. A 1-10 NPS-style scale or a 1-100 score can mislead engines into treating 8 as 8 / 5 = ridiculous if the scale ceiling is not declared.
4. Attach the AggregateRating to one itemReviewed target (or nest it inside the parent). Reusing the same rating across multiple entities triggers Google's November 2025 ambiguity rule (Search Engine Journal, 2025).

Product pattern

Product is the most common AggregateRating consumer. The minimal valid form:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Sony WH-1000XM6 Wireless Headphones",
  "sku": "SONY-WH1000XM6-BLK",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.6,
    "reviewCount": 312
  }
}

Product rich results for review snippets are restricted to first-party reviews about the seller's own product (Google Search Central, review snippet). Aggregating reviews you sourced from a third-party widget (Trustpilot, Capterra, Yelp) without complying with the third-party reviews policy is a frequent source of manual actions. Yotpo, Trustpilot, and Bazaarvoice provide compliant integrations that emit the markup correctly.

SoftwareApplication pattern

For software apps and SaaS products, the parent type is SoftwareApplication (or MobileApplication/WebApplication). Google additionally requires applicationCategory and operatingSystem for the Software App rich result:

{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Notion",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Web, macOS, Windows, iOS, Android",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.7,
    "ratingCount": 18420,
    "bestRating": 5,
    "worstRating": 1
  }
}

ratingCount is appropriate here because most app stores capture a numeric rating with no required text body; reviewCount would inflate the figure if combined.

LocalBusiness pattern

LocalBusiness is eligible only for sites that capture reviews about other businesses — a directory or review platform such as Yelp or TripAdvisor (Google Search Central, review snippet). A bakery cannot publish AggregateRating about itself on its own site and earn the star result; that is the self-serving-review violation, and it is enforced both by automated structured-data quality classifiers and by manual actions (Blue Array, structured data review).

A compliant directory entry:

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Tartine Bakery",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "600 Guerrero St",
    "addressLocality": "San Francisco",
    "addressRegion": "CA",
    "postalCode": "94110",
    "addressCountry": "US"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.4,
    "reviewCount": 2178
  }
}

Course pattern

The Course rich result was simplified in mid-2025 — Google retired the standalone Course Info rich result on June 12, 2025 (Search Engine Journal, 2025) but kept the Course list / review snippet support. AggregateRating remains valuable on Course for AI engine extraction even where the rich result is no longer rendered:

{
  "@context": "https://schema.org",
  "@type": "Course",
  "name": "Practical Generative Engine Optimization",
  "description": "How to earn citations from ChatGPT, Perplexity, and Google AI Overviews.",
  "provider": {
    "@type": "Organization",
    "name": "Geodocs Academy"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.8,
    "reviewCount": 246
  }
}

Decimal handling and locale gotchas

Google requires a dot for the decimal separator inside structured data — 4.4, never 4,4 (Google Search Central, review snippet). The visible page can render 4,4 for European locales using the content attribute pattern in Microdata or RDFa, but the JSON-LD value must use the dot form. Failure to follow this rule is one of the most common silent rich-result drops on European e-commerce sites.

For non-1-5 scales, declare both bestRating and worstRating even if one of them is the default. A 1-10 NPS-style scale must show bestRating: 10; an A-F letter scale should declare both ends as text values.

Google policy violation triggers

The most common manual-action triggers, in order of frequency observed across Google Search Central forum threads:

1. Self-serving reviews on LocalBusiness — a business publishing AggregateRating about itself on its own site, outside of the directory exception.
2. Mismatched markup vs visible content — the page shows 4.2 stars but the markup says 4.9, or the page shows 50 reviews but the markup says 5,000.
3. Reviews not on the same page — the AggregateRating points to reviews that live on a different URL with no clear path to them.
4. Reused rating targets — the same AggregateRating attached to multiple itemReviewed entities, flagged by Google's November 2025 clarification.
5. Empty or sentinel rating values — ratingValue: "" or ratingValue: 0 on a product with zero reviews. Omit the entire block instead.
6. Third-party badge cloaking — inserting a Trustpilot or G2 widget but emitting the AggregateRating with no compliant integration.

Common mistakes

• Setting ratingValue as a string with locale-specific decimal separator ("4,4").
• Treating bestRating/worstRating as required when they are not — omit on a 1-5 scale.
• Using Course AggregateRating and expecting the retired Course Info rich result to render.
• Combining reviewCount and ratingCount to mean the same thing; they have distinct semantics.
• Reusing one AggregateRating across product variants when each SKU has its own review pool.
• Marking up an aggregateRating on a page where the reviews are not actually visible to users.

FAQ

Q: Is AggregateRating required for the review-snippet rich result?

Yes if you want star ratings beside an aggregated score. For a single review, use Review with a nested reviewRating instead. The two types are not interchangeable: AggregateRating describes the average across many reviewers, Review describes one reviewer's verdict (Google Search Central, review snippet).

Q: What do I do when a product has zero reviews?

Omit the AggregateRating block entirely. Do not emit ratingValue: 0, ratingValue: "", or reviewCount: 0; both Google's validator and AI extractors treat those as low-quality signals. Add the markup back when the first real review lands.

Q: Can I aggregate reviews from a third-party platform?

Only through compliant integrations. Yotpo, Trustpilot, Bazaarvoice, and similar review platforms emit AggregateRating that follows Google's third-party reviews policy. Hand-rolling markup that quotes a third-party badge without their integration is a frequent manual-action trigger.

Q: Do I need to set bestRating and worstRating on a 1-5 scale?

No. Both default to 5 and 1 respectively per the schema.org Rating type. Set them explicitly only when your scale is non-default — 1-10 NPS, percentage, letter grade, etc.

Q: What is the difference between reviewCount and ratingCount?

reviewCount is the number of full text reviews. ratingCount is the number of numeric-only ratings, which may include reviewers who clicked stars without writing a body. Pages that capture both should publish both fields; pages with only one type should publish only that one.

Q: Do AI engines actually use AggregateRating in their answers?

Yes. ChatGPT search and Perplexity quote ratings and review counts directly from AggregateRating markup, and Google AI Overviews uses the same fields when summarising product, software, or course pages. Engines also fact-check the figure against the visible page; markup that contradicts what the user sees is treated as an integrity signal against the source.