Skip to content

Review & Rating Schema

By Matthew Edgar · Last Updated: September 26, 2023

If you have reviews or ratings on your website, you can use schema code to mark up that content for Googlebot. This can enhance your website’s listing in search results and, hopefully, generate more clicks to your website. Google currently supports and will typically use review and rating schema for content about books, courses, events, local businesses, movies, products, recipes, and software apps.

Two Types: Simple Review vs. Aggregate Rating

There are two types of review and rating schema: simple reviews and aggregate ratings. Simple reviews and aggregate ratings both provide a rating about a particular item. Where they differ is in the number of reviews that feed the rating.

Simple reviews contain a single review and rating about an item. For example, a film critic writes a review about a movie and provides a single rating for that movie. These simple reviews are sometimes referred to as editorial reviews. The schema type for a simple review is Review.

Example of a Simple Review in Google’s search results

Next, we have aggregate ratings, which are sometimes referred to as community ratings or customer reviews. Unlike a simple review, an aggregate rating is the average of the ratings provided by many different individual reviewers. For example, IMDb collects many ratings about a movie to generate an aggregate rating for that movie. The schema type for an aggregate rating is AggregateRating.

Example of Aggregate Rating in Google’s search results

What is Nesting Schema?

Simple reviews and aggregate ratings provide information about the review itself and information about the item reviewed. The review uses one type of schema while the item reviewed uses a different type of schema.

Nesting simply means one type of schema is contained in another type of schema. So, the schema containing the review can be nested in the schema for the item reviewed. Or, the schema for the item reviewed can be nested in the schema containing the review. However it is nested, Google will still understand there is an item reviewed and there is some type of rating and review for that item reviewed.

How you should nest your schema depends on the nature of your website. An ecommerce website is organized around products so typically the schema containing the review is nested within the schema describing the product. That makes the product the primary type. However, for a website that reviews software, it would probably make more sense to keep reviews as the primary type. So, the information about the software could be nested within the schema about the software.

How to Add Simple Review Schema to Your Website

Simple Review schema is appropriate to use when you have a page on your website reviewing a single item. While there are many properties you can use within Review schema, the required properties for Google to use this schema are:

  • author (this can be a Person or an Organization)
  • item reviewed (in the itemReviewed property)
  • item name (in the name property of itemReviewed)
  • rating (in reviewRating with the type of Rating for a simple review)
  • rating value (the numerical value of the rating in the ratingValue property within reviewRating)

If you don’t specify an alternative, Google will assume the rating value is on a scale between 1 and 5, with 1 as the lowest rating and 5 as the highest. If your website uses a different scale, you can specify a custom high point in the bestRating property and the custom low point in the worstRating property.

It is also common to include the date the review was published in the datePublished property. Google treats this as a recommended property.

We can see each of those properties, in the code below about a product called Awesome Widget that has been reviewed by Jane Jones. This review rated this product a 14 and uses a custom 0-100 scale.

<script type="application/ld+json">
{
     "@context": "https://schema.org/",
     "@type": "Review",
     "itemReviewed": {
          "@type": "Product",
          "image": "https://www.example.com/great-product-shot.jpg",
          "name": "Awesome Widget",
          "offers": {
               "@type": "Offer",
               "price": "1.23",
               "priceCurrency": "USD"
          }
     },
     "reviewRating": {
          "@type": "Rating",
          "ratingValue": "14",
          "bestRating": "100",
          "worstRating": "0"
     },
     "author": {
          "@type": "Person",
          "name": "Jane Jones"
     },
     "publisher": {
          "@type": "Organization",
          "name": "Test Company"
     },
     "datePublished": "2023-09-01"
}
</script>

Nest Simple Review Schema

The code above shows the information about the item reviewed (the product) nested within the review schema. Instead, if we wanted to nest this simple review schema inside the product, we can flip the order of those two pieces of information.

To begin changing the order, let’s break that code above into two parts. The first part of the schema code above is information about the review itself. That is everything in the code above except for the itemReviewed property, which would be this part of the code (note this code snippet is not valid schema):

{
     "@context": "https://schema.org/",
     "@type": "Review",
     "reviewRating": {
          "@type": "Rating",
          "ratingValue": "14",
          "bestRating": "100",
          "worstRating": "0"
     },
     "author": {
          "@type": "Person",
          "name": "Jane Jones"
     },
     "publisher": {
          "@type": "Organization",
          "name": "Test Company"
     },
     "datePublished": "2023-09-01"
}

The second part of the schema code above is information about the item reviewed, which is everything contained within itemReviewed, this code (note this code snippet is not valid schema):

     "@type": "Product",
     "image": "https://www.example.com/great-product-shot.jpg",
     "name": "Awesome Widget",
     "offers": {
          "@type": "Offer",
          "price": "1.23",
          "priceCurrency": "USD"
     }

To nest the information about the review in the product, we need to put the schema describing the product first, as our main type, and then add the review within the product. To put the review within the product, we use the review property. In the example below, you can see the product schema is listed first and then we have the Review schema nested within it. However, if you compare the first and second examples, you’ll see they contain exactly the same information just in a different order.

<script type="application/ld+json">
{
     "@context": "https://schema.org/",
     "@type": "Product",
     "image": "https://www.example.com/great-product-shot.jpg",
     "name": "Awesome Widget",
     "offers": {
         "@type": "Offer",
         "price": "1.23",
         "priceCurrency": "USD"
     },
     "review": [{
         "@type": "Review",
         "reviewRating": {
             "@type": "Rating",
             "ratingValue": "14",
             "bestRating": "100",
             "worstRating": "0"
         },
         "author": {
             "@type": "Person",
             "name": "Jane Jones"
         },
         "publisher": {
             "@type": "Organization",
             "name": "Test Company"
         },
         "datePublished": "2023-09-01"
     }]
 }
</script>

How a Simple Review Will Show in Search Results

You can preview how the schema code will look using the Rich Result Testing Tool. Enter in the code snippet and Google will return an evaluation of the page. There will be a link on this evaluation screen to “Preview Results”. After clicking to preview the results with the code above, we see the following example. This correctly reflects the simple review, including showing the name of the reviewer and the rating provided.

Keep in mind that Google won’t always use your schema code to enhance search result listings, even if an enhancement is shown in this preview. If Google doesn’t enhance your search result listing, that doesn’t necessarily mean there is something wrong with your code.

How to Add Aggregate Ratings Schema to Your Website

Aggregate Rating schema is appropriate when you have, or could have, ratings from multiple people about a particular item. The aggregate rating is an average of all individual ratings. For aggregate rating schema, Google requires the following properties:

  • item reviewed (in the itemReviewed property)
  • item name (in the name property of itemReviewed)
  • rating value (in the property ratingValue)

You also need to include either the rating count or the review count (or both). Rating count is specified within the property ratingCount and says how many unique ratings have been provided for the item reviewed. Review count is specified in the reviewCount property and specifies the number of unique reviews that have been provided for the item reviewed. A rating is a numerical value (4 out of 5) and a review is the text of the review (“This is great!”).

Should you use ratingCount or reviewCount? If you allow people to post reviews on your website along with the website, it is more common to use reviewCount. If you only collect ratings on your website, using ratingCount likely makes more sense. You can also provide both, though doing so is uncommon.

Finally, like with simple reviews, Google will assume the rating value provided is on a scale between 1 and 5, with 1 as the lowest rating and 5 as the highest. If that isn’t the scale used on your website, you can provide a custom scale using the bestRating and worstRating properties.

Bringing that together, here is an example of an aggregate rating for a product. In this example, the aggregate rating value is 4.7 on a 0-10 scale and that is based on 42 different reviews.

<script type="application/ld+json">
 {
        "@context": "https://schema.org/",
        "@type": "AggregateRating",
        "itemReviewed": {
            "@type": "Product",
            "image": "https://www.example.com/great-product-shot.jpg",
            "name": "Awesome Widget",
            "offers": {
                "@type": "Offer",
                "price": "1.23",
                "priceCurrency": "USD"
            }
        },
      "ratingValue": "4.7",
      "bestRating": "10",
      "worstRating": "0",
      "reviewCount": "42"
 }
</script>

Nesting Aggregate Rating Schema

We can also nest the aggregateRating property within the item reviewed. Remember, there are two pieces of information provided in the schema and the order those pieces are presented doesn’t matter. In the example above, we nested the product within aggregateRating and in the example below, we flip the order to nest the aggregateRating within the product. This is the more common approach taken for ecommerce websites presenting information about the product along with the rating.

<script type="application/ld+json">
 {
     "@context": "https://schema.org/",
     "@type": "Product",
     "image": "https://www.test.com/great-product-shot.jpg",
     "name": "Awesome Widget",
     "offers": {
         "@type": "Offer",
         "price": "1.23",
         "priceCurrency": "USD"
     },
     "aggregateRating": {
           "@type": "AggregateRating",
         "ratingValue": "4.7",
         "bestRating": "10",
         "worstRating": "0",
         "ratingCount": "42"
     }
 }
</script>

Adding Reviews to aggregateRating

While not required, you can also provide the individual reviews in the aggregateRating schema. If you do choose to show reviews, you don’t necessarily need to show all reviews but could show the first set of reviews, such as showing the first 10 or showing the best and the worst review. However many reviews you choose to add, you can add those in the review property. The reviews property contains an array of simple reviews that follows the rules for simple reviews discussed earlier in this article.

<script type="application/ld+json">
{
     "@context": "https://schema.org/",
     "@type": "Product",
     "image": "https://www.test.com/great-product-shot.jpg",
     "name": "Awesome Widget",
     "offers": {
         "@type": "Offer",
         "price": "1.23",
         "priceCurrency": "USD"
     },
     "aggregateRating": {
         "@type": "AggregateRating",
         "ratingValue": "4.7",
         "bestRating": "10",
         "worstRating": "0",
         "ratingCount": "42"
     },
     "review": [
        {
             "@type": "Review",
             "reviewRating": {
                 "@type": "Rating",
                 "ratingValue": 10,
                 "bestRating": "10",
                 "worstRating": "0"
             },
             "author": {
                 "@type": "Person",
                 "name": "Luke"
             },
             "headline": "I love it",
             "reviewBody": "This is great."
         },
         {
             "@type": "Review",
             "reviewRating": {
                 "@type": "Rating",
                 "ratingValue": 0,
                 "bestRating": "10",
                 "worstRating": "0"
             },
             "author": {
                 "@type": "Person",
                 "name": "Leia"
             },
             "headline": "I hate it",
             "reviewBody": "This is terrible."
         }
     ]
 }
</script>

How Aggregate Ratings Show in Search Results

Using the Rich Results Testing Tool, we can preview this code to see how it could appear if Google decides to use it to enhance the search result. Google translates the 10-point scale used in this schema markup into a 5-point scale for the stars. Unlike the Simple Review markup, the Aggregate Rating markup doesn’t show the names of the individual reviewers but it does provide a count of how many reviews there were (from ratingCount).

Example of Aggregate Rating in Search Results

Final Thoughts

As you begin working with schema on your website, remember to always follow Google’s guidelines, including adding in all required properties. Also, as with all schema, the information presented in the schema should also be represented on the page; don’t specify a review in schema only if it isn’t presented on the page.

Once you have schema on your website, you can review how Google is interacting with it and how it is helping your website’s performance in Google Search Console. Learn more about monitoring schema in Google Search Console:

How to monitor schema in Google Search Console

Contact me if you need help or have questions about using review and rating schema on your website.

You may also like

Google Search Console: Page Indexing Report

Is Google indexing every page on your website? If not, why not? To answer these questions, you need to use the Page Indexing Report in Google Search Console. Find out how to use and understand this report.

How to Check HTTP Response Status Codes

Every page on every website returns an HTTP response status code. How do you check the status code for your website’s pages? What tools can you use to test status codes? What do the status codes mean?

Noindex vs. Nofollow vs. Disallow

Are you confused about the difference between noindex, nofollow and disallow commands? All three are powerful tools to use to improve a website’s organic search performance, but each has unique situations where they are appropriate to apply.