AggregateRating Schema: Making Reviews Machine-Readable for AI

What Is AggregateRating Schema?

AggregateRating Schema is a schema.org structured data type that summarizes review and rating data for a product, service, organization, or other entity. It provides machine-readable access to three key data points: the average rating value (e.g., 4.8 out of 5), the total number of reviews or ratings, and the scale used (typically 1 to 5 stars). This data enables search engines to display star rating rich results and helps AI models cite accurate rating information in recommendations.

AggregateRating is not a standalone schema type -- it is nested inside a parent type as the aggregateRating property. The most common parent types are Product, LocalBusiness, Organization, SoftwareApplication, and Course. The AggregateRating summarizes all individual reviews into a single composite metric.

For AI SEO, AggregateRating serves as a structured social proof signal. When ChatGPT answers "What is the best email marketing platform?", it factors in available rating data when forming its recommendation. Platforms with structured AggregateRating data provide the AI with reliable numbers to cite, while platforms relying on unstructured mentions of "highly rated" or "top-reviewed" provide weaker signals.

Why Review Data Matters for AI Citations

Review data is a critical factor in how AI models evaluate and recommend products and services. Understanding why review signals matter helps you prioritize AggregateRating implementation.

Reviews as authority signals

AI models treat review data as a form of crowd-sourced authority. A product with 500 reviews averaging 4.7/5 signals strong market validation. AI models are more likely to recommend products with substantial, positive review histories because citing well-reviewed products reduces the risk of the AI making a poor recommendation.

Quantitative comparison capability

When AI compares products, it needs quantifiable metrics. Rating data provides this. "Product A is rated 4.8/5 with 340 reviews, while Product B is rated 4.2/5 with 85 reviews" is a concrete comparison the AI can present. Without structured rating data, the AI must either omit the comparison or rely on vague qualitative assessments.

Third-party review platforms and AI

AI models also pull review data from third-party platforms like G2, Capterra, Trustpilot, and Yelp. Having AggregateRating Schema on your own site complements these third-party signals. For a deeper exploration of how review platforms influence AI citations, see our guide on review platforms as AI signals.

The review count factor

Review count matters as much as rating value. AI models apply a Bayesian prior to ratings: a 5.0/5 rating from 2 reviews is treated as less reliable than a 4.6/5 rating from 500 reviews. The reviewCount property in AggregateRating gives AI the data needed for this calibration.

Complete JSON-LD Implementation

Here is AggregateRating Schema nested inside Product Schema:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "AImetrico Pro",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "bestRating": "5",
    "worstRating": "1",
    "reviewCount": "142",
    "ratingCount": "187"
  }
}

Key fields explained

• ratingValue -- The average rating as a decimal or integer (e.g., "4.8")
• bestRating -- The highest possible rating on your scale (typically "5")
• worstRating -- The lowest possible rating on your scale (typically "1")
• reviewCount -- Number of reviews with written text
• ratingCount -- Total number of ratings (includes ratings without text)

Note: You should include either reviewCount or ratingCount (or both). reviewCount refers to reviews with written feedback. ratingCount includes star-only ratings without text.

Properties Reference

| Property | Required | Description | |---|---|---| | @type | Yes | Must be "AggregateRating" | | ratingValue | Yes | Average rating value (numeric) | | bestRating | Recommended | Highest possible rating (default: 5) | | worstRating | Recommended | Lowest possible rating (default: 1) | | reviewCount | Yes* | Number of reviews with text (at least one of reviewCount or ratingCount) | | ratingCount | Yes | Total number of ratings including star-only | | itemReviewed | Conditional | Reference to the reviewed entity (required if not nested inside parent) |

Non-standard rating scales

If your rating system uses a scale other than 1-5 (e.g., 1-10 or 1-100), specify the bestRating and worstRating properties accordingly. AI models and Google will normalize the score for display.

{
  "@type": "AggregateRating",
  "ratingValue": "92",
  "bestRating": "100",
  "worstRating": "0",
  "reviewCount": "340"
}

AggregateRating on Different Schema Types

AggregateRating can be nested inside many different parent schema types. Here are the most common implementations.

Product pages

The most common use case. Rating data helps AI recommend products in response to "best of" and comparison queries.

LocalBusiness pages

For businesses with physical locations, AggregateRating combined with LocalBusiness Schema helps AI answer location-based recommendation queries: "Best pizza in Chicago" or "Highest-rated dentist near me."

SoftwareApplication

For apps and software tools, AggregateRating inside SoftwareApplication Schema helps AI answer tool recommendation queries. This is especially relevant for SaaS products listed on app marketplaces.

Organization

For the company itself (as opposed to individual products), AggregateRating inside Organization Schema signals overall company reputation. This is useful for service businesses where clients rate the company rather than individual products.

Course

For educational content, AggregateRating inside Course Schema helps AI recommend courses and training programs. "Best online Python course" queries frequently cite course ratings.

Adding Individual Review Schema

While AggregateRating summarizes all reviews, you can also include individual Review objects for richer structured data. Each Review includes the author, rating, date, and review text.

{
  "@type": "Product",
  "name": "AImetrico Pro",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "142"
  },
  "review": [
    {
      "@type": "Review",
      "author": {
        "@type": "Person",
        "name": "Sarah Chen"
      },
      "datePublished": "2026-02-15",
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5"
      },
      "reviewBody": "AImetrico showed us exactly where our brand appeared in ChatGPT and Gemini. We increased our AI visibility score from 32 to 71 in three months."
    }
  ]
}

Individual reviews provide AI with specific testimonials it can quote. The review text can be cited as social proof when AI recommends your product.

Common Mistakes and Guidelines

1. Fabricating ratings -- AggregateRating must reflect real reviews. Google's guidelines explicitly prohibit fake or self-generated review Schema. Violations result in manual actions and loss of rich results.

2. Rating only your own product on a comparison page -- If your page compares multiple products, either add AggregateRating for all or for none. Rating only your own product appears biased.

3. Not updating ratings -- If your AggregateRating shows 50 reviews from 2024 while the page displays 200 reviews, the mismatch reduces trust. Automate rating synchronization.

4. Using AggregateRating on pages without visible reviews -- Google requires that the rating data in Schema correspond to visible content on the page. If users cannot see reviews, the Schema should not contain AggregateRating.

5. Missing bestRating and worstRating -- Without these, parsers assume a 1-5 scale. If your scale differs, omitting these creates incorrect star displays.

6. Self-reviews -- Ratings from the company itself (e.g., rating your own product 5/5) violate Google's guidelines and do not carry AI citation weight.

Validate your implementation using the tools in our testing structured data guide.