Skip to content

Review & Rating Schema

January 18, 2022

If you have reviews or ratings on your website, you can use schema code to mark up those reviews and ratings. By doing so, you 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 about books, courses, events, how-to, local businesses, movies, products, recipes, and software apps. In this guide, we’ll discuss how you add review and rating schema to your website, including discussing the key concepts you need to know about review and rating schema.

Example of Review Schema

Two Types: Simple Review vs. Aggregate Rating

There are two types of review and rating schema: simple and aggregate. 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. As an example, think about a film critic who writes a review about a movie and provides a rating. This is a single review with a single rating. These simple reviews are sometimes referred to as editorial reviews. The schema type for a simple review is Review.

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. As an example, think about an ecommerce website where multiple people can leave reviews about a product for sale. The schema type for an aggregate rating is AggregateRating.

What is Nesting Schema?

There are two main types of information provided in review and rating schema (simple or aggregate): 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. These different schema types can be represented in different ways within the code by using nesting.

What does it mean to nest schema? Any type of schema can be the main type of schema or it can be contained within another type of schema. Nesting simply means one type of schema is contained in another type of schema.

When it comes to simple reviews or aggregate rating schema, we have two choices. First, the review schema can be the main type and have the information about the item reviewed nested within it. Or, second, the item reviewed can be the main type and have the review schema nested within it instead. Both directions communicate the same information: there is an item reviewed and there is some type of rating and review for that item reviewed. In short, nesting changes the order the information is shared but not the information shared in the schema.

How should you nest your schema? It depends on the nature of your website. An ecommerce website is organized around products so it would make sense that the product (the item reviewed) would be the main type of schema and reviews about that product would be nested. However, for a website that reviews software, the review itself would make more sense as the main type because a software review website would be organized around reviews and the software review could be nested within the review.

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:

  • 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 otherwise, 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 that isn’t the scale you are using on your website, you can provide a different scale by specifying the high point of your scale in the bestRating property and the low point of your scale in the worstRating property.

Along with the required properties, it is also common to include the date the review was published (in the datePublished property), the name of the review author (in author), and the publisher (an Organization with the publisher property). You can also add the review itself in schema in the reviewBody property, though that isn’t as common since the review body can be quite long.

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 2, but was scaled on a 0-10 scale instead of the assumed five-point scale so the best and worst rating are also specified.

<script> {
     "@context": "https://schema.org/",
     "@type": "Review",
     "itemReviewed": {
          "@type": "Product",
          "image": "https://www.test.com/great-product-shot.jpg",
          "name": "Awesome Widget",
          "offers": {
               "@type": "Offer",
               "price": "1.23",
               "priceCurrency": "USD"
          }
     },
     "reviewRating": {
          "@type": "Rating",
          "ratingValue": "2",
          "bestRating": "10",
          "worstRating": "0"
     },
     "author": {
          "@type": "Person",
          "name": "Rey"
     },
     "publisher": {
          "@type": "Organization",
          "name": "Test Company"
     },
     "datePublished": "2022-01-01",
     "reviewBody": "This was not an awesome widget."
}
</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 is not valid schema):

{
     "@context": "https://schema.org/",
     "@type": "Review",
     "reviewRating": {
          "@type": "Rating",
          "ratingValue": "2",
          "bestRating": "10",
          "worstRating": "0"
     },
     "author": {
          "@type": "Person",
          "name": "Rey"
     },
     "publisher": {
          "@type": "Organization",
          "name": "Test Company"
     },
     "datePublished": "2022-01-01",
     "reviewBody": "This was not an awesome widget."
}

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 is not valid schema):

     "@type": "Product",
     "image": "https://www.test.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.test.com/great-product-shot.jpg",
     "name": "Awesome Widget",
     "offers": {
         "@type": "Offer",
         "price": "1.23",
         "priceCurrency": "USD"
     },
     "review": [{
         "@type": "Review",
         "reviewRating": {
             "@type": "Rating",
             "ratingValue": "2",
             "bestRating": "10",
             "worstRating": "0"
         },
         "author": {
             "@type": "Person",
             "name": "Rey"
         },
         "publisher": {
             "@type": "Organization",
             "name": "Test Company"
         },
         "datePublished": "2022-01-01",
         "reviewBody": "This was not an awesome widget."
     }]
 }
</script>

How Simple Review Show in Search Results

You can preview how the schema code will look using the Rich Result Testing Tool. When you go to the tool, you can 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.

Example of Simple Review schema

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, reviews and ratings from multiple people about a particular item. The aggregate rating takes an average of all of those ratings and puts that number in the schema. For aggregate rating schema, you need to specify the:

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

Also in aggregate rating schema, you need to specify 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.

Should you use ratingCount or reviewCount? If you collect reviews on the website along with the website, it is more common to use reviewCount. If you only collect ratings on your website, then using ratingCount likely makes more sense. You can also provide both, though that is very 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 you are using on your website, you can provide a different scale by specifying the high point of your scale in the bestRating property and the low point of your scale in the worstRating property.

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.test.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. Note that 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 the listing appears (or could appear if Google decides to use it to enhance the search result listing). One interesting thing you’ll notice is that Google translates the 10-point scale used in this schema markup into a 5-point scale for the stars. Also, unlike the Simple Review markup, the Aggregate Rating markup doesn’t show the names of the individual reviewers.

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

How To Manage Parameters

Parameters can create duplicate content, slow down website crawling, and disrupt rankings. What are the best ways to avoid these problems? In this article, we’ll review how to find and manage parameters on a website.

Performing Regular Tech SEO Checks with SE Ranking

Although a Tech SEO Audit can be completed using a variety of tools, in this post, I want to walk through how we can do each of these tasks using SE Ranking’s audit tool.

How To Fix 404 Errors On Your Website

How do you find the 404 errors on your website? Once found, how do you fix the 404 errors? What tools can help? Find out in this in-depth 404 guide!