# AggregateRating: the average rating in Schema.org

> What AggregateRating is in Schema.org, which properties Google asks for to show stars, which ratings you cannot mark up and how to check your product page.

URL: https://clione.ai/glossary/aggregaterating/
Lang: en

The stars that sometimes appear under a Google result, with "4.6" and the number of reviews next to them, come from something specific in the page's code: an AggregateRating node. It is a type from [Schema.org](/glossary/schema-org/). It is not a review: **it is the average of all of them, with their count**. Each individual review, with its author and its text, is another type, [Review](/glossary/review-schema/). It matters to you because it is the property in your [structured data](/glossary/structured-data/) that is most visible when it works, and the one with the most rules about where the numbers can come from.

## How it works

Schema.org defines AggregateRating as **the average rating based on multiple ratings or reviews**. It is a kind of rating (Rating) and, with the `aggregateRating` property, it can hang off a brand, a creative work, an event, an offer, an organization, a place, a service or a [Product](/glossary/product-schema/).[^schema-org-aggregaterating] Its properties are few:[^schema-org-aggregaterating]

| Property       | What it says                          |
| -------------- | ------------------------------------- |
| `ratingValue`  | The average score                     |
| `ratingCount`  | How many ratings make up that average |
| `reviewCount`  | How many reviews there are            |
| `bestRating`   | The highest value the scale allows    |
| `worstRating`  | The lowest value the scale allows     |
| `itemReviewed` | What is being rated                   |

Google uses it for the review snippet, which it describes as a short excerpt of a review or a rating, usually the average of many people's scores, and which can appear in [rich results](/glossary/rich-results/) or in the knowledge panel with stars and other summary data.[^google-review-snippet] For that it asks for:[^google-review-snippet]

- **`ratingValue`**, the average, as a number, fraction or percentage.
- **`ratingCount` or `reviewCount`**, at least one of the two. Google spells out the difference: the first counts the ratings of the item on your site; the second, the people who left a review, with a score or without one.
- **`itemReviewed`**, what is being rated, unless the rating is nested inside another type with the `aggregateRating` property, which is the normal case on a [product page](/glossary/product-page/): then it is omitted.
- **The scale, if it is not the usual one.** If `bestRating` is missing, Google assumes it is 5; if `worstRating` is missing, 1.

On a product, the rating is one of three doors to the product snippet: Google requires the name and at least one of these three properties, `review`, `aggregateRating` or `offers`.[^google-product-snippet]

The rules matter as much as the properties. The ratings you mark up have to be visible to people visiting the page, and **Google asks you not to gather reviews or ratings from other sites**.[^google-review-snippet] And there is an exception that surprises many businesses: if the rated [entity](/glossary/entity/) controls the reviews about itself, its pages with local business or organization markup do not qualify for stars.[^google-review-snippet] The rule is about that markup, the business's markup about itself; the ratings of the products it sells are marked up on the product.

## In a store

A product page with its reviews and its node, side by side. **Fictional example**: the store, the product, the score and the number of reviews are made up.

| What the product page shows | AggregateRating property    | Value |
| --------------------------- | --------------------------- | ----------------------------------------------------------------------------------------------- |
| "4.6 out of 5"              | `ratingValue`               | `"4.6"`                                                                                         |
| "38 reviews"                | `reviewCount`               | `"38"`                                                                                          |
| Stars from 1 to 5           | `bestRating`, `worstRating` | They can be omitted: it is the default scale                                                    |

```json
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Coastal linen shirt, blue",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "38"
  }
}
```

No `itemReviewed`, because it sits inside the product.[^google-review-snippet] No `bestRating`, because the store's scale runs from 1 to 5, the one Google assumes.[^google-review-snippet] And with the same numbers the customer sees: if the product page says 38 reviews, the node says 38, because structured data cannot mark up what the reader does not see.[^google-sd-policies] If the product page shows no reviews, the node carries no rating. Stores that publish with Clione follow that same rule: the rating on the product node comes from the store's own reviews (on BigCommerce, the platform's; on Shopify, the standard review [metafields](/glossary/shopify-metafields/) that the main apps write), and a product with no reviews carries none.


Marking up a score out of 10 without stating the scale. If your store rates from 1 to 10 and the node says `"ratingValue": "9.2"` with no `bestRating`, Google understands the scale goes up to 5, because that is what it assumes when it is missing.[^google-review-snippet] The average you see on the product page and the one the machine reads stop being the same.


## How to check

1. **Search for `aggregateRating` in the source code of a product page** and note `ratingValue`, `ratingCount` or `reviewCount`, and `bestRating` if there is one.
2. **Compare them with what the customer sees** at that moment: the same average and the same number of reviews, visible on the product page.[^google-review-snippet]
3. **Check the scale.** If your ratings do not run from 1 to 5, the node has to say so with `bestRating` and `worstRating`.[^google-review-snippet]
4. **Confirm where the reviews come from**: they have to be from your site, not gathered from others.[^google-review-snippet]
5. **Run the URL through the [Rich Results Test](/glossary/rich-results-test/)** to see what it detects and with which errors or warnings.[^rich-results-test]

## Related concept: Review

AggregateRating and Review are often marked up together and answer different questions. **Review is one specific opinion**, with whoever wrote it and their score; **AggregateRating is the average of many**, with their count.[^schema-org-aggregaterating] A product can carry both, and both types serve Google's review snippet, each with its own required properties.[^google-review-snippet] If you want the stars to show with the number of reviews, the node that says it is AggregateRating; if you want to highlight what one customer wrote, it is Review. What your customers write, before it becomes markup, is [product reviews](/glossary/product-reviews/), and they have an entry of their own.

To go further, the [structured data reading path](/learn/structured-data/) lays out the rest of the terms, and the [Organization](/glossary/organization-schema/) entry explains which markup describes the business and why it is not the place for its stars.