Aizii Learn · AI Search

[← Back to Learn](https://aizii.ai/learn)

# How to add review schema so AI trusts your products

Review schema is structured data that labels the reviews on a product page in a machine-readable form. It tells a system, without guessing from page text, which product was reviewed, who wrote each review, what rating each reviewer gave, and what the average rating is across all of them. An AI system deciding whether to recommend your product can use that labeled summary as one signal among others, because a rating it can parse is easier to trust than a rating it has to scrape out of a paragraph. The schema does not create trust on its own. Trust comes from reviews that are real, visible on the page, and marked up exactly as they appear.

Two types do this work. Review describes one person's verdict on one product. AggregateRating describes the average of many, with a rating value and a count. Both attach to the product they are about, usually nested inside the Product block.

## The rules first, because they decide whether the markup counts

Google publishes review snippet guidelines, and the rules are strict. Follow them before you write any code.

**Mark up only reviews that are visible on the page.** Google says the review content you mark up must be readily available to users from the marked-up page, and that users should be able to see the text of the review and its rating. If you use AggregateRating, users should be able to see that aggregate rating on the page. A rating that lives only in your database, or only in the markup, is not eligible. It is markup with no page behind it.

**One product per review, not a category.** Provide review information about a specific item, not about a category or a list of items. A review of one serum belongs on that serum's page. A rating for your whole store does not belong on a product page.

**Do not aggregate reviews from other websites.** Google says this plainly in its review snippet guidelines. A review count that mixes your own reviews with reviews copied from a marketplace is not your product's rating.

**Do not mark up fake or undisclosed incentivized reviews.** Google says sites should not include fake reviews, or reviews written in exchange for a benefit such as money, discounts, vouchers, or free products when the incentive is not clearly and prominently disclosed, on the page or in the markup. A review that is not based on a genuine experience of the product does not belong in the markup. If a reviewer received a benefit, disclose it clearly on the page, and check the vendor docs in Sources before you mark that review up at all.

**If you show several individual reviews, also show the aggregate.** Google says that when a page includes multiple individual reviews, it should also include an aggregate rating of those reviews. The aggregate is the summary an AI system reads first, and it only means something when the individual reviews behind it are there to check.

**Self-serving reviews have a limit.** Google defines a review as self-serving when a review about an entity is placed on the website of that same entity. Its guidelines say that if the entity being reviewed controls the reviews about itself, its pages using LocalBusiness or any other type of Organization structured data are ineligible for the star review feature. A Product page is a different case: Product is one of the features Google lists as eligible for a review snippet, alongside Book, Course list, Event, Movie, Recipe, and Software App. So mark up reviews on the product they describe, and do not expect stars for reviews of your own business on your own Organization pages.

**Valid markup is eligibility, not a promise.** Google says that when it finds valid reviews or ratings markup, it may show a rich snippet that includes stars and other summary info. May, not will. The same applies to AI answers: review schema makes your rating readable, it does not promise that any system will cite it or show stars.

## The complete review block

Here is a full JSON-LD block for a skincare store. In the example, \[yourdomain.com\] is a placeholder, replacing yourdomain.com with your actual domain. The store, the product, and the reviewers are fictional, and the numbers are teaching samples for your own store. Replace every value with reviews that are actually visible on your own product page.

```
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Meadow Repair Serum",
  "image": [
    "https://[yourdomain.com]/images/meadow-repair-serum.jpg"
  ],
  "description": "Fragrance-free repair serum for sensitive skin, with ceramides and squalane.",
  "sku": "MB-SERUM-02",
  "brand": {
    "@type": "Brand",
    "name": "Meadow Botanicals"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://[yourdomain.com]/products/meadow-repair-serum",
    "price": "48.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "bestRating": "5",
    "reviewCount": "87"
  },
  "review": [
    {
      "@type": "Review",
      "author": {
        "@type": "Person",
        "name": "Priya N."
      },
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5",
        "bestRating": "5"
      },
      "reviewBody": "Gentle on my sensitive skin and absorbed fast, with no stinging on the first use."
    },
    {
      "@type": "Review",
      "author": {
        "@type": "Person",
        "name": "Daniel K."
      },
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "4",
        "bestRating": "5"
      },
      "reviewBody": "Good texture and no scent. I wish the bottle were larger for the price."
    }
  ]
}
</script>
```

Field by field:

-   **aggregateRating.ratingValue**: the average rating, on the scale your page uses. State bestRating as 5 so the scale is explicit. A value of 4.6 means little without the scale it sits on.
-   **aggregateRating.reviewCount**: the number of reviews the average is based on. Use reviewCount for the count of reviews, or ratingCount for the count of ratings. Google requires one of the two for an AggregateRating. The count must match the reviews a shopper can read on the page.
-   **aggregateRating.bestRating**: the top of your scale. Include it, so a system does not have to assume your scale runs to 5.
-   **review.author**: a real name, typed as Person. Google requires an author for a Review. An anonymous or made-up author does not meet the rule.
-   **review.reviewRating.ratingValue**: the rating that one reviewer gave, on the same scale as the aggregate. Keep the scale identical in both places.
-   **review.reviewBody**: the text of the review, as it appears on the page. Keep it identical to the visible text. A paraphrase in the markup and a different text on the page are two versions of the same review, and a system may trust neither.
-   **review, nested in Product**: nesting the reviews inside the Product block says what they are reviews of, without a separate itemReviewed field. If a Review stands alone, it needs itemReviewed with the product name instead.

## What to leave out

**No reviews yet means no review fields.** If a product has no reviews, leave aggregateRating and review out entirely. The Product block is still valid with offers alone. An empty rating, a rating of zero, or a copied count from another site is worse than no rating, because it states a fact that is not true.

**Do not mark up a rating summary that the page does not show.** If your page shows stars but no count, do not invent a count for the markup. If it shows a count but no average, do not compute an average from reviews the page does not list. Add the visible summary to the page first, then mark it up.

**Do not cherry-pick.** Google says that when you include multiple reviews, you should include all of the reviews that are visible to people on the page. Marking up only the five-star reviews while the page shows a mix is a true representation problem, and it is the kind of mismatch that costs the markup its eligibility.

**Do not copy reviews from a marketplace.** A review written about your product on another site belongs to that site. If you want that feedback on your page, ask the reviewer to leave it on your store, and mark it up only after it is visible there.

## How reviews help an AI answer

An AI system asked to recommend a serum has to weigh more than price. It needs to know whether buyers liked the product, and whether the complaints repeat. A labeled aggregate gives it the average in a form it can read. Individual reviews give it the reasons behind the average: gentle on sensitive skin, good texture, bottle size as a complaint. That is why the reviewBody matters, not just the number. A system that can read the reasons can answer a specific question, such as whether the serum suits sensitive skin, instead of repeating a bare rating.

None of this makes a system recommend your product. It makes your product legible when a system is already weighing it. The recommendation still depends on the product, the price, the stock status, and everything else the system can verify.

## Validate before you ship

Two free tools, no signup, and they check different things:

1.  Google's Rich Results Test: paste a product URL and it shows which review fields Google detects, with errors and warnings per field.
2.  The Schema Markup Validator: checks the JSON-LD against the schema.org vocabulary itself, which catches typos in property names that Google's tool may not flag.

Run both on a product page with reviews, and then read the page yourself. The validators cannot tell you the review count in the markup is higher than the reviews on the page. Only a side-by-side read can. Check that every marked-up review appears on the page, that the aggregate matches the visible average and count, and that no review in the markup is missing from the page.

### Say you run a skincare store with 87 reviews

Say you run a small skincare store, and one serum has 87 reviews visible on its page, averaging 4.6 out of 5. Your markup carries the same two facts, ratingValue 4.6 and reviewCount 87, and it nests two individual reviews with real names and their exact text. An AI system asked for a gentle serum for sensitive skin can read the average, read that reviewers call it gentle, and weigh it against other serums with their own labeled ratings.

Now say a second store has the same average, but its markup lists 240 reviews while its page shows 40. The count in the markup cannot be checked against the page, so the system has a rating it cannot verify. The fix is simple: the count in the markup is the count on the page, updated when new reviews arrive, generated from the same review data that renders the page.

## Common mistakes

**A rating with no reviews behind it.** The aggregate says 4.8 from 120 reviews, and the page shows three reviews. Leave the fields out until the reviews are real and visible.

**Different scales in the aggregate and the individual reviews.** The aggregate uses a 5-point scale and one review uses a 10-point scale. Pick one scale, state bestRating in both places, and keep it identical everywhere.

**A review of the store on a product page.** Store-level praise belongs on a page about the store, not nested inside a product. Keep each review attached to the specific product it describes.

**An app that emits a second rating block.** A reviews app or SEO app may emit its own aggregateRating with a different count from yours. Audit the page source for every script tag of type application/ld+json before adding your own, and keep one owner for review markup.

**Expecting stars as a reward for correct code.** Correct code makes a page eligible for a review snippet. It does not promise stars in search results or a citation in an AI answer.

## What this guide does not cover

This guide covers the Review and AggregateRating fields on a product page. It does not cover collecting reviews, which is a separate job, or the price and availability fields in the same Product block, which is our guide to marking up prices and availability, or the full Product block, which is our product schema guide. It also does not cover keeping ratings accurate as new reviews arrive, which is monitoring work, or turning a recommendation into a completed purchase, which is the transaction layer.

## Check your own brand now

Run the free scan. It takes seconds, no signup, and shows whether AI crawlers can read your product pages today: aizii.ai/aeo-scan

[Run the free scan](https://aizii.ai/aeo-audit)

## Sources

-   Google Search Central, Review snippet structured data (specific): [https://developers.google.com/search/docs/appearance/structured-data/review-snippet](https://developers.google.com/search/docs/appearance/structured-data/review-snippet)
-   Google Search Central, Merchant listing structured data (specific): [https://developers.google.com/search/docs/appearance/structured-data/merchant-listing](https://developers.google.com/search/docs/appearance/structured-data/merchant-listing)
-   Schema.org, Review type (specific): [https://schema.org/Review](https://schema.org/Review)
-   Schema.org, AggregateRating type (specific): [https://schema.org/AggregateRating](https://schema.org/AggregateRating)
-   Google Rich Results Test (general docs): [https://search.google.com/test/rich-results](https://search.google.com/test/rich-results)
-   Schema Markup Validator (general docs): [https://validator.schema.org/](https://validator.schema.org/)

Note: links marked specific point to the page that supports the claim in this guide. Links marked general docs point to the vendor's general docs section for that topic, not to a page that proves every step. Check the vendor docs for the current path before relying on a menu name or click path in this guide.
