Aggregate Rating Schema Generator

Aggregate rating schema is structured data that summarizes the collective ratings for an item. Instead of describing a single review, it represents the overall picture: the average rating value, the total number of ratings or reviews, and the scale used. It uses Schema.org's AggregateRating type, which gets nested inside a parent entity like a Product, LocalBusiness, Recipe, Course, or other ratable item.

When search engines read this markup, they can display star ratings directly in your search listing. Those familiar gold stars with a review count next to them, like "4.6 (2,340 reviews)," are generated from aggregate rating schema. This visual element is one of the most effective ways to increase click-through rates from search results without changing your ranking position.

The markup lives in a JSON-LD script tag on the page where the ratings apply. It should reflect real, verifiable reviews collected on your site. Google is strict about this, and the rules around when and how you can use aggregate rating schema have tightened considerably over the years.

When Google processes valid aggregate rating schema, it can display a rich snippet below your page title in search results. The typical format shows a row of stars (filled proportionally to your average rating), the numeric rating value, and the total number of reviews in parentheses.

The visual impact is significant. Listings with star ratings draw the eye immediately because they introduce color and shape into an otherwise text-heavy results page. Studies consistently show that listings with star ratings earn higher click-through rates than identical listings without them, often by a substantial margin.

Star ratings can appear for various entity types including products, local businesses, recipes, courses, books, movies, apps, and events. The exact presentation may vary slightly depending on the entity type and the device, but the core format of stars plus review count is consistent.

It's worth noting that Google doesn't guarantee rich snippet display for every page with valid schema. Google's algorithms decide whether to show rich results on a query-by-query basis. Having valid markup makes you eligible, but display depends on factors like the relevance of the rating to the query, the trustworthiness of your site, and how the results page is composed.

The generator covers all the properties Google recognizes for AggregateRating, along with the parent item context that's required for the schema to be complete.

ratingValue. The average rating across all reviews. This can be a decimal like 4.3 or a whole number like 4. It represents the central data point that gets displayed as the star graphic in search results.

bestRating. The highest possible value on your rating scale. Most sites use a 5-star scale, making this value 5. If your system uses a 10-point scale, set this to 10. Google needs this to render the stars proportionally. A rating of 8 on a 10-point scale should display as roughly four out of five stars, not eight out of five.

worstRating. The lowest possible value on your scale. Defaults to 1 if not specified. Include it explicitly if your scale starts at something other than 1, which is uncommon but does happen.

ratingCount. The total number of individual ratings submitted. This counts every rating, including those without a written review. If 500 people gave you a star rating but only 200 wrote reviews, ratingCount is 500.

reviewCount. The total number of ratings that include a written review. This is a subset of ratingCount. If every rating on your site comes with a review, ratingCount and reviewCount will be the same. Include whichever is most accurate, or both if you track them separately.

itemReviewed. The parent entity that the ratings apply to. This is where you define what's being rated, whether it's a Product, LocalBusiness, SoftwareApplication, Course, or another Schema.org type. The aggregate rating doesn't exist in a vacuum; it has to be attached to something.

Aggregate rating schema needs to be nested inside a parent entity. Google supports star rating rich results for a specific set of parent types, and using an unsupported type means your ratings won't generate rich snippets even if the markup is technically valid.

• Product. Physical or digital products for sale. This is the most common use case and the most straightforward path to star ratings in search results.
• LocalBusiness (and subtypes). Restaurants, dentists, law firms, auto shops, and other local businesses. Ratings here typically come from customer reviews collected on your website.
• Recipe. Recipes with user ratings. The stars appear alongside other recipe rich result elements like cook time and calorie count.
• Course. Educational courses and training programs. The rating reflects student reviews of the course content and experience.
• Book. Reader ratings for books. Applicable for publishers, bookstores, and review sites.
• Movie and TVSeries. Viewer ratings for entertainment content. Primarily used by review and entertainment platforms.
• SoftwareApplication. App ratings and reviews. Used by app directories, review sites, and SaaS product pages.
• Event. Attendee ratings for events, conferences, and performances.
• Organization. Broader organizational ratings, though Google's support for rich results on this type is more limited than for Product or LocalBusiness.

If your use case doesn't fit one of these types cleanly, the schema is still valid from a technical standpoint, but Google may not display rich results for it. Bing and other search engines have their own criteria that may differ.

Google has progressively tightened its guidelines around aggregate rating schema because it was widely abused. Understanding the current rules is essential for keeping your rich results and avoiding manual actions.

Reviews must be collected on your site. The ratings in your schema must come from reviews submitted directly on the page or site where the schema appears. You cannot import ratings from Google, Yelp, Amazon, or any third-party platform and mark them up as your own. This is one of the most commonly violated rules and one Google actively enforces.

Ratings must be for the specific item on that page. A product page should only display aggregate ratings for that specific product, not for your store overall or for a different product. A local business page should show ratings for that specific location, not an aggregate across all locations. Each page's schema should reflect ratings relevant to the content on that page.

Self-serving ratings are not allowed on certain pages. Google does not permit aggregate rating schema on your own homepage, "About Us" page, or other pages where you're rating yourself rather than a specific product or service. A SaaS company can't place a 4.8-star aggregate rating on their homepage and expect rich results. The schema belongs on individual product, service, or location pages where external customers have left reviews.

The ratings must be visible on the page. Google requires that the information in your schema be present and visible to users on the page itself. If your schema claims 4.5 stars from 1,200 reviews, users should be able to see that rating information and access those reviews on the page. Hidden or invisible rating data violates the guidelines.

No fake or incentivized reviews. The underlying reviews powering your aggregate rating must be genuine. Fabricated ratings, reviews written by employees, or reviews generated through incentive programs (offering discounts or gifts in exchange for positive reviews) all violate Google's policies and can result in manual actions.

If you want to use aggregate rating schema, you need a legitimate review collection system on your site. There are several approaches depending on your platform and business type.

Built-in CMS review functionality. WordPress with WooCommerce has a native product review system. Shopify includes product reviews through its free Reviews app or third-party apps like Judge.me and Loox. These systems collect reviews directly on your product pages, making them eligible for aggregate rating schema.

Third-party review platforms that embed on your site. Services like Trustpilot, Bazaarvoice, Yotpo, and Stamped.io collect reviews and embed them on your pages. The key distinction is that the reviews must be displayed on your site, not just hosted on the third-party platform. If the reviews are embedded and visible on your page, they can support your aggregate rating schema.

Custom review forms. You can build your own review collection system with a simple form that captures a star rating, review text, and reviewer name. Store the data in your database and display it on the relevant pages. This gives you full control but requires development effort and moderation to prevent spam.

Post-purchase email requests. Send automated emails after a purchase or service completion asking customers to leave a review on your site. Include a direct link to the review form on the relevant product or service page. This is the most effective method for building a steady stream of legitimate reviews.

Whichever method you use, make it easy for customers to leave reviews and display them prominently. A review system that's buried or difficult to use won't generate enough volume to make aggregate rating schema worthwhile.

Yes, service businesses can use aggregate rating schema by nesting it inside a LocalBusiness, ProfessionalService, or another appropriate Schema.org type that represents the business or service. A plumber, a law firm, a marketing agency, and a consulting practice can all implement aggregate rating schema on their service pages.

The same rules apply. Reviews must be collected on your own site, they must be from real customers who used the actual service, and the rating data must be visible on the page. Service businesses often have a harder time collecting on-site reviews because there's no natural "post-purchase" flow like ecommerce has. Building a follow-up email sequence after project completion or service delivery is the most reliable way to accumulate reviews over time.

Place the schema on individual service pages rather than just your homepage. A law firm might have aggregate ratings on their personal injury page reflecting client reviews for that practice area, and separate ratings on their family law page. This keeps the schema relevant to the specific content and compliant with Google's guidelines about item-specific ratings.

Placing self-serving ratings on your homepage. Adding a 5-star aggregate rating to your own homepage, landing page, or marketing page where the ratings aren't tied to a specific product or service violates Google's guidelines. This was common practice years ago, but Google now considers it spammy and may issue a manual action.

Using ratings from third-party platforms you don't control. Scraping your Google Business Profile rating or importing your Amazon product ratings into your site's schema is not allowed. Those reviews belong to those platforms. Your schema must reflect reviews collected on your own domain.

Inflating numbers. Setting your ratingCount to 5,000 when you have 50 actual reviews, or rounding a 3.8 average up to 4.5, is fabrication. Google can compare your schema data against what's visible on the page, and inconsistencies can trigger review or removal of your rich results.

Applying the same aggregate rating across multiple pages. Each page should have its own distinct ratings for the specific item on that page. Copying the same 4.7 stars and 890 reviews across every product page signals to Google that the data isn't legitimate. If a product doesn't have reviews yet, leave the schema off that page until it does.

Not updating the schema as new reviews come in. Your aggregate rating schema should reflect your current review data. If your rating was 4.2 from 100 reviews six months ago and you now have 4.5 from 300 reviews, update the markup. Static schema that never changes looks stale and can become inaccurate. Automate the update process through your CMS or review platform if possible.

Forgetting to validate. A missing comma, an unquoted property name, or a misplaced bracket breaks the entire JSON-LD block. Always validate your generated schema with a JSON-LD validator and test it through Google's Rich Results Test before publishing. Revalidate whenever you make changes to the markup or the system that generates it.