Review Schema for AI Citations: The Complete 2026 Implementation Guide

Review schema is the Schema.org markup - the Review, AggregateRating, and Rating types - that encodes customer ratings and written reviews in a machine-readable format AI answer engines can parse without guessing at page layout. When ChatGPT, Perplexity, or Google AI Overviews answer a query like "is [product] any good" or "best [category] tools", they preferentially retrieve pages that state a rating value, a review count, and individual review text as structured data, rather than pages where that same information is scattered across star icon images and unstructured testimonial blocks.

AggregateRating and Review schema sit alongside Product, FAQPage, and HowTo as some of the highest-value structured data types for AI citation, but they are also among the most often implemented incorrectly - or fabricated outright, which both conventional search engines and AI retrieval systems now actively penalise. This guide covers the difference between the three related schema types, the JSON-LD structure that actually validates, and the mistakes that quietly disqualify a page from citation even when the markup looks correct at a glance.

How AI engines use review and rating data

A retrieval-augmented generation system answering a comparative or evaluative query needs a fast, reliable way to establish social proof for each candidate source. Prose sentences like "customers love this product" are unverifiable and inconsistent between pages. A structured ratingValue and reviewCount pair is not: it is a discrete, comparable fact the engine can extract, cite, and place alongside a competitor's figure in the same response.

• ChatGPT Search: surfaces aggregate rating and review count directly in shopping and recommendation answers when Product and AggregateRating schema are both present and consistent with visible page content
• Perplexity: quotes individual review snippets as supporting evidence for evaluative claims, favouring reviews with an attributed author and a specific, non-generic reviewBody over vague five-word testimonials
• Google AI Overviews: AggregateRating is one of the signals behind star-rating rich results, and the same markup that earns those rich results in standard search also feeds evaluative AI Overview panels
• Claude: treats review counts as a scale-of-evidence signal - a rating built on 4 reviews is weighted very differently from one built on 400, and the reviewCount property is what makes that distinction legible

Review, AggregateRating, and Rating: the three schema types explained

These three types are related but not interchangeable, and mixing them up is one of the most common implementation errors. Each answers a different question about the same underlying evaluation.

Review schema

A single Review type represents one written evaluation by one author, of one item (a Product, LocalBusiness, Book, or any reviewable entity). It requires a reviewRating, an author, and typically a reviewBody containing the actual text. Review schema is what lets an AI engine quote a specific opinion rather than only a number.

AggregateRating schema

AggregateRating summarises many individual ratings into one figure: a ratingValue, a reviewCount (or ratingCount), and optionally bestRating and worstRating bounds. It is nested inside the entity being rated - a Product or LocalBusiness - rather than existing as a standalone page element, and it is the property most AI engines display alongside a star icon in a citation.

Rating schema (standalone)

Rating is the generic building block that both Review (via reviewRating) and AggregateRating extend. You rarely author a bare Rating object directly - it almost always appears nested inside one of the other two types, carrying the ratingValue, bestRating, and worstRating fields.

The correct JSON-LD structure

The minimum viable implementation nests an AggregateRating summary and an array of individual Review objects inside the entity being reviewed. Every review needs its own reviewRating, author, and reviewBody - a review with only a star count and no text is far weaker evidence for citation purposes.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "CiteRank AEO Audit",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "182",
    "bestRating": "5",
    "worstRating": "1"
  },
  "review": [
    {
      "@type": "Review",
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5",
        "bestRating": "5"
      },
      "author": {
        "@type": "Person",
        "name": "Priya Shah"
      },
      "datePublished": "2026-06-14",
      "reviewBody": "The Fix Kit flagged a missing FAQPage schema block that had been silently broken for months. Fixed it in ten minutes and started showing up in Perplexity citations within a week."
    }
  ]
}
</script>

Implementation in Next.js (App Router)

As with any JSON-LD block, derive the schema from the same data source that renders the visible star rating and review list on the page. Hardcoding the schema separately from the UI is how the two drift apart over time - a common and easily avoidable cause of AI citation confidence dropping without an obvious trigger.

interface ReviewData {
  authorName: string;
  ratingValue: number;
  datePublished: string;
  reviewBody: string;
}

function ReviewSchema({
  productName,
  ratingValue,
  reviewCount,
  reviews,
}: {
  productName: string;
  ratingValue: number;
  reviewCount: number;
  reviews: ReviewData[];
}) {
  const schema = {
    '@context': 'https://schema.org',
    '@type': 'Product',
    name: productName,
    aggregateRating: {
      '@type': 'AggregateRating',
      ratingValue,
      reviewCount,
      bestRating: 5,
      worstRating: 1,
    },
    review: reviews.map((r) => ({
      '@type': 'Review',
      reviewRating: {
        '@type': 'Rating',
        ratingValue: r.ratingValue,
        bestRating: 5,
      },
      author: { '@type': 'Person', name: r.authorName },
      datePublished: r.datePublished,
      reviewBody: r.reviewBody,
    })),
  };
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

Common mistakes that block AI citation

Review schema is unusually easy to get technically valid and substantively wrong at the same time. A page can pass every validator check and still be quietly excluded from AI answers if the underlying evidence looks manufactured or inconsistent.

• Reviews with no visible counterpart on the page - if the JSON-LD lists 182 reviews and the page shows 4, the mismatch is a quality signal violation that AI crawlers and manual quality reviews both catch
• A reviewCount that never changes across weeks or months - static counts read as fabricated, since real review volumes grow, even slowly, over time
• Every review scoring a perfect 5, with no 3s or 4s anywhere in the distribution - AI engines and users alike treat unanimous five-star ratings as a stronger signal of curation than of quality
• Generic, interchangeable reviewBody text ("Great product, highly recommend!") that could apply to any item in any category - these carry almost no citable evidence value compared with specific, detailed text
• Self-authored or incentivised reviews presented as independent - both Google's review schema policies and general AEO trust signals penalise reviews that are not genuinely from independent customers
• Missing the author property entirely - an anonymous review is weaker evidence than an attributed one, in the same way an anonymous byline underperforms a named author on an article

Where review schema matters most

Review and rating signals are not equally valuable across every page type. They carry the most weight wherever a query is inherently evaluative - the user is deciding between options, not just looking up a fact.

• E-commerce product pages, where "is X worth it" and "best X under $Y" queries depend directly on AggregateRating to differentiate otherwise similar listings
• SaaS pricing and comparison pages, where review counts substitute for the word-of-mouth trust a buyer cannot get from marketing copy alone
• Local business listings, where NAP-consistent LocalBusiness schema plus AggregateRating is often the deciding factor between two similarly ranked options in a "best near me" AI answer
• Service and professional pages (agencies, consultants, contractors) where individual Review text with named authors substitutes for the case-study depth larger brands can otherwise rely on

Validating your review and rating schema

Validate structure and eligibility separately from checking that the numbers are actually true. A schema can be perfectly valid JSON-LD and still misrepresent the page if nobody checks it against the visible review list after a content update.

• Google Rich Results Test (search.google.com/test/rich-results): confirms AggregateRating and Review eligibility and previews the star rating as it would appear in search results
• Schema.org validator (validator.schema.org): checks specification compliance, including whether reviewRating and author are present on every Review object
• A manual spot-check: pick three reviews from the JSON-LD and confirm the same author name and review text appear, verbatim, in the visible page content
• CiteRank audit: checks AggregateRating and Review schema presence and consistency alongside all other AEO signals in a single pass