Think about the last time you searched for a product on Google. Your eye immediately landed on the listing with five gold stars and 238 reviews sitting right below the title. The other nine results were plain blue links. You clicked the one with the stars without thinking twice.
That is not a coincidence. Star ratings in Google search results are one of the most direct trust signals available to e-commerce brands in organic search. They appear because of a specific type of schema markup called AggregateRating, nested inside your Product schema. For Indian D2C brands competing against Amazon and Flipkart in Google search, getting those stars to appear in organic results is one of the few ways to create visual parity without spending on ads. Understanding both Review and Rating Schema is crucial for leveraging these benefits.
What Are AggregateRating and Review Schema?
The combination of Review and Rating Schema can enhance your product visibility and credibility significantly.
AggregateRating schema: the star ratings you see in search results
AggregateRating schema is structured data that communicates your product average rating and total review count to search engines. It is almost always nested inside your Product schema rather than used alone. When Google validates your AggregateRating markup and finds that it accurately reflects visible content on your page, your listing becomes eligible to display star ratings directly in the search result.
The most important thing to understand: AggregateRating does not create reviews. It tells Google how to read and display review data that already exists visibly on your page. If users cannot see the star rating and review count on your product page, you cannot mark it up in schema.
Review schema: individual customer reviews
Review schema marks up individual customer reviews on your product pages. Where AggregateRating gives the summary (4.3 stars from 156 reviews), Review schema marks up the individual reviews themselves: the reviewer name, their star rating, the date they wrote it, and the review body text.
For most Indian e-commerce websites, AggregateRating is the higher-priority implementation because it is what produces the star rating display in search results. Individual Review schema is useful supplementary markup but less critical for SERP visibility.
The difference between ratingCount and reviewCount
| Property | What it counts | When to use it |
| ratingCount | Total star ratings including those with no written text | Use when your platform allows rating without a written review |
| reviewCount | Total reviews that include written text alongside the rating | Use when every rating includes a written comment |
| Both together | Most complete picture of your review data | Use when your platform captures both types separately |
| Practical note: Google accepts either ratingCount or reviewCount. If your platform only captures star ratings without requiring written comments, use ratingCount. If every rating comes with written text, use reviewCount. Using neither causes a validation error in the Rich Results Test. |
Why Star Ratings in Search Results Matter for Indian E-Commerce
| 15-35% | higher click-through rates for listings with star ratings vs identical listings without them (schemavalidator.org, 2026) |
| 88% | of Indian consumers trust online reviews as much as personal recommendations (BrightLocal, 2026) |
| 4.0+ | average star rating threshold below which displaying ratings in search results hurts CTR more than it helps |
| 5-10 | minimum genuine reviews recommended before implementing AggregateRating schema on any product page |
For Indian e-commerce brands, there is an additional dimension. Marketplace listings on Amazon and Flipkart appear in Google search with star ratings by default because of their structured data infrastructure. An independent Indian D2C brand with correct AggregateRating schema gets the same visual treatment in organic results, making it much harder for users to skip past to the marketplace result automatically.
There is also a critical caveat: a 2.5-star rating displayed in a search result is a stronger reason NOT to click than having no rating at all. Implement AggregateRating only when you have enough genuine reviews and a strong enough average to make the display work in your favour.
Google Review Schema Policies: What Every Indian E-Commerce Brand Must Know
This is the most important section of this guide. Google review schema policies are strict, and violations can result in a manual action that removes all rich results across your entire domain, not just the affected pages.
Policy 1: Reviews must be genuine and from real customers
Reviews must be genuine, unedited comments from real customers. No fake reviews. No reviews written by staff. No reviews solicited with incentives in exchange for positive ratings. Google systems are increasingly sophisticated at detecting anomalous review patterns, and the consequences of being caught are severe.
For Indian e-commerce brands using third-party review platforms like Judge.me, Yotpo, or Trustpilot, the reviews those platforms capture are eligible for schema markup as long as they come from genuine verified purchasers.
Policy 2: Review content must be visible on the page
Whatever you mark up in the schema must be immediately visible to users on the page. You cannot mark up reviews that are hidden, collapsed behind a click, or only accessible through JavaScript that Googlebot cannot render. If you use AggregateRating, users must be able to see that aggregate rating on the page. If you mark up individual reviews, the review text, author name, and rating must all be visible.
| Practical approach: Display 3 to 5 individual reviews visibly on the product page and keep the rest accessible through a Show More section. This satisfies the visibility requirement while keeping the page clean. Marking up 150 reviews in schema when only the aggregate rating is visible is a policy violation. |
Policy 3: Schema data must exactly match visible page data
The ratingValue and reviewCount in your schema must exactly match the numbers visible on your page. If your schema says 4.5 stars and 100 reviews but your page shows 4.3 stars and 95 reviews, that is a violation. This happens easily when schema is static in your template but reviews are added dynamically. Always generate AggregateRating values dynamically from your live review database.
Policy 4: Self-serving reviews on LocalBusiness pages are not eligible
Since 2019, Google stopped showing star ratings for LocalBusiness and Organisation schema types where the business controls the reviews on its own website. A physical store or service business cannot show star ratings for reviews it hosts itself.
This restriction does NOT apply to Product schema. Reviews about specific products hosted on your own e-commerce website are fully eligible for product rich results including star ratings. This is the most important distinction for Indian e-commerce brands.
Policy 5: Reviews must be for the specific product on that page
Product schema reviews must be about the specific product being sold on that page. You cannot use reviews of your general store quality or customer service in your Product AggregateRating schema. Store-level reviews belong in Organisation or LocalBusiness schema where they will not generate star ratings in search results.
AggregateRating and Review Schema: All Properties Explained
AggregateRating properties
| Property | Status | What it communicates | Indian e-commerce example |
| ratingValue | Required | Average rating as a decimal number | 4.3 (not 4.3/5, just the number as a string or float) |
| ratingCount or reviewCount | Required (one) | Total number of ratings or written reviews | 238 |
| bestRating | Recommended | Maximum possible rating on your scale | 5 (for a 1 to 5 star scale) |
| worstRating | Recommended | Minimum possible rating on your scale | 1 |
| itemReviewed | Required if standalone | Item being rated when not nested in Product | Only needed when AggregateRating is not nested inside Product |
Individual Review properties
| Property | Status | What it communicates | Best practice |
| author | Required | Person who wrote the review (Person type) | Include reviewer name exactly as displayed on your site |
| reviewRating | Required | Individual reviewer rating (Rating type) | Include ratingValue, bestRating, and worstRating |
| datePublished | Recommended | When the review was submitted | Provides freshness signals. Use ISO format: 2026-03-15 |
| reviewBody | Recommended | Written text of the review | Include full visible review text from the page |
| name | Optional | Headline or title for the review | Include if your platform captures review titles separately |
Complete JSON-LD Code Examples for Indian E-Commerce
Example 1: AggregateRating nested in Product schema (most common setup)
This is the implementation used by most Indian e-commerce websites. The AggregateRating is nested directly inside Product schema, which is the Google-recommended approach.
| <script type=”application/ld+json”> { “@context”: “https://schema.org”, “@type”: “Product”, “name”: “Handcrafted Brass Diya Set – Pack of 5”, “description”: “Traditional handcrafted brass diyas for Diwali and daily puja. Set of 5 with decorative finish.”, “brand”: {“@type”: “Brand”, “name”: “ArtisanIndia”}, “sku”: “DIYA-BRASS-5PK”, “offers”: { “@type”: “Offer”, “price”: “599”, “priceCurrency”: “INR”, “availability”: “https://schema.org/InStock” }, “aggregateRating”: { “@type”: “AggregateRating”, “ratingValue”: “4.6”, “reviewCount”: “312”, “bestRating”: “5”, “worstRating”: “1” } } </script> |
Example 2: AggregateRating plus individual Review schemas
Use this when you want to mark up both the overall rating summary and the individual visible reviews on the page. Google may choose to display either in search results.
| <script type=”application/ld+json”> { “@context”: “https://schema.org”, “@type”: “Product”, “name”: “Handcrafted Brass Diya Set – Pack of 5”, “brand”: {“@type”: “Brand”, “name”: “ArtisanIndia”}, “offers”: { “@type”: “Offer”, “price”: “599”, “priceCurrency”: “INR”, “availability”: “https://schema.org/InStock” }, “aggregateRating”: { “@type”: “AggregateRating”, “ratingValue”: “4.6”, “reviewCount”: “312”, “bestRating”: “5”, “worstRating”: “1” }, “review”: [ { “@type”: “Review”, “author”: {“@type”: “Person”, “name”: “Sunita Patel”}, “datePublished”: “2026-03-10”, “reviewBody”: “Beautiful quality brass. Excellent craftsmanship and fast delivery to Ahmedabad.”, “reviewRating”: { “@type”: “Rating”, “ratingValue”: “5”, “bestRating”: “5”, “worstRating”: “1” } }, { “@type”: “Review”, “author”: {“@type”: “Person”, “name”: “Ramesh Kumar”}, “datePublished”: “2026-02-28”, “reviewBody”: “Good product but packaging could be better for gifting purposes.”, “reviewRating”: { “@type”: “Rating”, “ratingValue”: “4”, “bestRating”: “5”, “worstRating”: “1” } } ] } </script> |
Example 3: Dynamic AggregateRating for WooCommerce (PHP approach)
For WooCommerce websites, always generate AggregateRating dynamically from live review data. Never hardcode the count in your template.
| // In your product template or functions.php // Pull live data from WooCommerce $rating_count = $product->get_rating_count(); // total ratings $avg_rating = $product->get_average_rating(); // e.g. 4.3 // Only output schema if minimum review threshold is met if ($rating_count >= 5) { $schema = array( “@context” => “https://schema.org”, “@type” => “Product”, “name” => get_the_title(), “aggregateRating” => array( “@type” => “AggregateRating”, “ratingValue” => number_format($avg_rating, 1), “ratingCount” => $rating_count, “bestRating” => “5”, “worstRating” => “1” ) ); echo ‘<script type=”application/ld+json”>’ . json_encode($schema) . ‘</script>’; } |
| Why dynamic generation matters: Hardcoding review counts in schema templates is one of the most common Indian e-commerce policy violations. As new reviews arrive, your schema count drifts away from the visible count on the page. This mismatch is a direct violation. Always generate AggregateRating values dynamically from your live review database. |
Platform-Specific Implementation for Indian E-Commerce
WooCommerce (WordPress)
WooCommerce has a built-in review system that stores ratings and review text in the WordPress database. The Rank Math SEO plugin free tier automatically pulls this data and generates AggregateRating schema for products that have been reviewed. After installing Rank Math, go to Rank Math > Schema and verify that the Product schema template includes aggregateRating generation.
Rank Math correctly generates AggregateRating with ratingValue, ratingCount, bestRating, and worstRating from your WooCommerce review data. It also conditionally omits AggregateRating on products with no reviews, preventing the empty schema violation.
If you use a third-party review plugin like Judge.me or Stamped.io, check whether the plugin generates its own schema markup. If it does, disable AggregateRating in Rank Math to avoid duplicate schema blocks. Run the Rich Results Test on any affected product page to confirm exactly one AggregateRating block appears.
| WooCommerce review plugin | Auto-generates schema | Compatible with Rank Math | Free tier |
| Rank Math (built-in) | Yes, from WooCommerce core reviews | Self (disable if using other plugin) | Yes |
| Judge.me | Yes, its own schema | Disable Rank Math aggregateRating | Yes |
| Stamped.io | Yes, its own schema | Disable Rank Math aggregateRating | Limited |
| Yotpo | Yes, its own schema | Disable Rank Math aggregateRating | Free tier available |
| WooCommerce core reviews only | Via Rank Math | Yes (default setup) | Yes (Rank Math free) |
Shopify
Shopify default themes include basic Product schema with AggregateRating if reviews exist. However, most Shopify stores use a third-party review app, and many of these apps generate their own schema independently of the theme.
The most important check is whether your review app and theme are generating duplicate AggregateRating blocks on the same page. Having two AggregateRating blocks on one page is a policy violation and Google may ignore both. Check your product pages using View Page Source and search for aggregateRating to confirm only one block exists.
Popular Shopify review apps that generate compliant AggregateRating schema for Indian stores include Judge.me (free tier), Okendo, and Yotpo. After installing a review app, test a product page URL in the Rich Results Test to confirm the schema is correct.
Custom builds
For custom Indian e-commerce platforms built on Laravel, Node.js, or Django, generate AggregateRating server-side by querying your reviews table for each product page render. Calculate the average rating and count at request time. Only include AggregateRating in the schema output when the review count meets your minimum threshold. Do not cache schema with stale review counts as this creates the mismatch violation.
Review Schema Mistakes That Get Indian E-Commerce Websites Penalised
- Implementing AggregateRating before enough genuine reviews exist. Wait until you have at least 5 to 10 genuine reviews with a 4.0 or above average. A low star average displayed in search results deters clicks more than no rating at all.
- Hardcoding review counts in schema templates. Your review count changes as customers add new reviews. A static number in schema that drifts out of sync with the visible page count becomes a policy violation once the difference becomes material.
- Marking up hidden or JavaScript-rendered reviews. If your review section loads via JavaScript and Googlebot cannot render it during crawling, the reviews are invisible to the crawler. Marking up invisible reviews is a direct violation.
- Using third-party aggregate scores presented as product ratings. Importing a Trustpilot or Google My Business score and displaying it as your product rating in schema markup is not compliant. Only mark up reviews that genuinely live on your own product page.
- Applying AggregateRating to category pages. AggregateRating must be nested inside a specific product entity. An aggregate rating on a category page listing multiple products has no valid association with any specific product and will not produce rich results.
- Duplicate AggregateRating blocks on the same page. Having both your theme and your review app generate separate AggregateRating blocks creates a conflict. Google may ignore both. Always check the Rich Results Test and confirm exactly one AggregateRating block per product page.
- Review count mismatch after a platform migration. Platform migrations frequently break schema accuracy. After any migration, audit product pages for schema accuracy and use the Rich Results Test on a sample of high-priority products before resubmitting your sitemap.
Third-Party Review Platforms Used by Indian E-Commerce Brands
| Platform | Schema generated | WooCommerce | Shopify | India pricing |
| Judge.me | AggregateRating + Review | Yes (plugin) | Yes (native) | Free tier available |
| Yotpo | AggregateRating + Review | Yes (plugin) | Yes (native) | Free tier available |
| Okendo | AggregateRating | Shopify only | Yes (native) | From ~Rs 2,500/month |
| Stamped.io | AggregateRating + Review | Yes | Yes (native) | Free tier limited |
| Google Customer Reviews | Store-level only (not product) | Plugin required | Via app | Free via Merchant Center |
| Important distinction: Google Customer Reviews generates store-level ratings visible in Google Shopping and Merchant Center. These do NOT generate product star ratings in organic search results. For organic star ratings you need product-level AggregateRating schema from genuine on-page product reviews. |
How to Test and Monitor Your Review Schema
Before you publish: two essential tools
- Google Rich Results Test — Paste your product page URL or the raw JSON-LD. This confirms whether your AggregateRating markup makes the page eligible for review snippets and shows any errors or warnings. Fix all critical errors before going live.
- Schema Markup Validator — Tests JSON-LD syntax against the full Schema.org vocabulary. Catches property type errors such as using a string where a number is expected in ratingValue, or missing required nested properties.
After you publish: Google Search Console
Google Search Console and navigate to Enhancements in the left sidebar. Look for the Review Snippets report or the Product Snippets report. Each shows valid pages, pages with warnings, and pages with errors across your entire site. Check this every two to four weeks. A spike in errors after a theme update, plugin update, or schema change needs immediate investigation.
Manual verification in search results
Search for several of your product names on Google after four to six weeks of schema implementation. If star ratings appear below your listing title, the implementation is working. If they do not appear after six weeks of validated error-free schema, use the URL Inspection tool in Search Console to request re-indexing of affected product pages.
Also Read: Product Schema Markup for E-Commerce Websites: Complete Setup Guide
Star Ratings in Search Results Are Earned, Not Installed
The gold stars that appear below a product listing in Google search are one of the most effective trust signals in organic e-commerce. They tell a potential buyer, before they have ever visited your site, that real people have bought this product and found it worth rating. For Indian D2C brands building credibility against established marketplace listings, this signal is enormously valuable.
But they only work when the underlying reviews are genuine, the schema accurately reflects what users see on the page, and the implementation follows Google policies. The shortcuts that seem tempting, fake reviews, inflated counts, hardcoded static numbers, all carry the risk of a manual action that removes rich results across your entire domain.
Build your review base honestly. Generate schema dynamically so it stays in sync with live data. Validate before publishing. Monitor in Search Console regularly. Every genuine review that comes in improves both your schema data and your conversion rate at the same time. That compound effect is the real value of doing this correctly.
| Disclaimer: This article is for informational purposes only. Review schema requirements and Google policies change regularly. Always refer to developers.google.com/search/docs/appearance/structured-data/review-snippet for current guidelines. Validate all schema using the Rich Results Test before publishing. |
FAQs about Review and Rating Schema:
AggregateRating schema is structured data nested inside Product schema that communicates your product average rating and total review count to Google, enabling star ratings to appear in search results before users click.
Google does not specify a minimum but the SEO convention is at least 5 to 10 genuine reviews with an average of 4.0 or above. A low star average shown in search results hurts CTR more than having no rating at all.
ratingCount is the total number of star ratings including those without written text. reviewCount is the number of ratings that include a written review. Use whichever matches how your platform captures customer feedback.
No. Since 2019, Google does not display star ratings for LocalBusiness or Organisation schema where the business controls the reviews. This restriction does not apply to Product schema on e-commerce product pages.
Yes. Google requires schema data to accurately reflect visible page content. A mismatch between schema and visible rating values is a policy violation that suppresses your rich results.
No. You can only mark up reviews that genuinely live on your product page. Importing third-party aggregate scores as your own product rating schema is not compliant with Google policies.
Two to six weeks is typical after correct schema implementation. Use Google Search Console URL Inspection to request re-crawling of product pages to speed up the process.
No. Showing 3 to 5 reviews visibly with a Show More option is sufficient. The AggregateRating can reflect the total count of all reviews. The rating value and count must match what is visibly displayed.
Google issues a manual action removing all rich results from schema markup across your entire domain. This is one of the most serious schema policy violations with no quick fix.
Yes. The free version of Rank Math pulls ratingValue and ratingCount from WooCommerce review data and generates compliant AggregateRating schema automatically for products that have been reviewed.
