What is Review schema and why does it matter for SEO?

Review schema is structured data using schema.org Review and AggregateRating types that tells Google "this page has a review with this star rating." When Google parses it correctly, your search result can display gold stars, review count, and rating value — which lift CTR by 30-40% versus standard text-only snippets, per Search Engine Land studies. Two main types matter: (1) Review represents a single review of a single thing (a product, business, recipe, etc.). (2) AggregateRating represents the average rating across multiple reviews. Most pages use AggregateRating to summarize all reviews. Both must be embedded as JSON-LD in a script tag in your page head, formatted per schema.org spec, and validated through Google Rich Results Test. Eligible page types for review snippets include: Product pages, Local Business pages, Software Application pages, Recipe pages, Book pages, Course pages, and Movie pages. Generic blog posts and homepages are NOT eligible — Google announced this restriction in 2019 to combat fake-review schema.

What is the difference between Review and AggregateRating?

Review schema describes a single review by a single person. It includes: author, reviewBody (the text), reviewRating (their stars), datePublished, and itemReviewed (what they reviewed). One Review schema = one customer review. AggregateRating schema describes the overall summary across many reviews. It includes: ratingValue (the average like 4.7), ratingCount or reviewCount (how many reviews contributed), and bestRating/worstRating (usually 5 and 1). One AggregateRating schema = the whole product summary. For SERP star ratings, AggregateRating is what triggers Google rich snippets in most cases. Individual Review schemas are useful for marking up each review in a long product page review list, but the SERP star comes from the AggregateRating value. Best practice: include BOTH on a product page — one AggregateRating for the SERP snippet, plus an array of Review schemas for the individual visible reviews. Our generator outputs both with proper itemReviewed nesting.

Does Google still show review stars in SERPs?

Yes, but only for eligible page types and content categories. As of 2024-2026, Google shows review stars in SERPs primarily for: Product, LocalBusiness (and subtypes like Restaurant, Hotel), SoftwareApplication, Recipe, Book, Course, MovieRated, and Event. Google removed review snippet eligibility for "self-serving reviews on a brand or service page" (e.g., your homepage saying "we are 4.9 stars"), reviews of "self" without a verifiable third-party source, and many service categories like SaaS providers without a specific Product child entity. The bar for showing stars also rose: pages need genuine review content visible on the page (not just hidden in schema), and the rating must come from real reviews you display. Pages that include schema for invisible or "cooked" reviews face manual penalties and complete loss of all rich results across the site. Our generator validates that the Review or AggregateRating you provide is legitimate (rating between 1-5, review count > 0, content matches schema spec).

How does Google detect fake review schema?

Google uses several detection mechanisms. (1) Manual reviewer team checks: random sampling of pages with review schema, especially in finance and health verticals. Pages that have invisible reviews (only in schema, not on page) get flagged. (2) Algorithmic patterns: pages with AggregateRating ratingValue 5.0 (perfect) on 10,000+ reviews trigger automatic review for being statistically improbable. (3) Cross-reference with third-party review sources: Trustpilot, G2, Capterra, Google Business Profile. If your site claims 4.9 stars but Trustpilot shows 3.2 for the same business, Google may discount your schema. (4) User feedback: clicking "report review" or "feedback" on rich results trains Google detection. Penalties for detected fake schema range from minor (loss of star snippet for that page) to severe (manual penalty deindexing the entire site). The May 2022 Google guidelines update specifically targeted "fake or misleading review markup" as a manual action category. Our generator only marks up real reviews from real sources you specify.

Can I use Trustpilot or Yelp ratings in my Review schema?

Yes, with proper attribution. The schema.org spec requires reviewedBy or sameAs to indicate the source. Example: AggregateRating schema with ratingValue: 4.6, ratingCount: 248, and a sameAs link to your Trustpilot page. Trustpilot and Google encourage this. The integrations are: (1) Trustpilot offers an official TrustBox widget that injects schema on your site. Free for Trustpilot subscribers. (2) Google Business Profile reviews can be referenced via sameAs URL but Google does not currently render them as your own page schema — only as Google Knowledge Panel content. (3) Yelp explicitly prohibits scraping and using their reviews in your schema. Use only Trustpilot, Capterra, G2, third-party review APIs you have license for, or your own first-party review system. Our generator includes specific Trustpilot, Capterra, and G2 integrations that pull AggregateRating from their APIs and format the schema correctly with proper sameAs attribution.

How do I add Review schema to a Shopify product page?

Three approaches in order of complexity. (1) Easiest: install a review app (Yotpo, Loox, Stamped.io, Judge.me) — they auto-inject Review schema on product pages with proper structure. Free tier of Judge.me includes schema; Yotpo and Stamped require paid plans for schema. (2) Manual: edit your theme product.liquid template to include a JSON-LD script tag with hardcoded ratings or Liquid variables. Works but requires updating each time ratings change. (3) Use our generator + theme custom code: generate the schema, paste into theme.liquid head section, update periodically. Good middle ground if you do not want a review app. Shopify itself does not inject Review schema by default. As of 2026, Shopify Plus stores can use the Online Store 2.0 metaobjects to manage review data and inject schema dynamically — more complex but allows full control. Verify your schema with Google Rich Results Test after deployment, regardless of method.

What is the JSON-LD format for AggregateRating?

JSON-LD is the recommended schema format because it is easier to maintain than microdata. Embed in a script tag like this: {"@context":"https://schema.org","@type":"Product","name":"Your Product","aggregateRating":{"@type":"AggregateRating","ratingValue":"4.7","reviewCount":"248","bestRating":"5","worstRating":"1"}} . Place in the page head or anywhere in the body before closing . Required fields for AggregateRating: ratingValue (decimal between worstRating and bestRating), and either reviewCount OR ratingCount (Google strongly recommends reviewCount when the count includes ratings with text reviews; ratingCount when it is just star ratings without text). Optional fields: bestRating (default 5), worstRating (default 1). The aggregateRating must be nested inside a parent type — Product, LocalBusiness, SoftwareApplication, Recipe, Book, Course, MovieRated, Event. Standalone AggregateRating without a parent will not produce rich snippets. Our generator outputs the full nested structure for whichever parent type you select.

Should I use JSON-LD or Microdata?

JSON-LD, almost always. Both produce identical SEO results — Google parses them equivalently — but JSON-LD has practical advantages: (1) It lives in a single script tag instead of being scattered through your HTML markup. (2) It is easier to generate dynamically. (3) It does not require refactoring your visible HTML. (4) Google explicitly recommends it in their Search Central documentation. Microdata embeds schema attributes directly into your HTML elements (itemtype, itemscope, itemprop), which couples schema tightly to display markup and breaks easily during redesigns. RDFa is the third option but barely used. The remaining case for microdata is hyper-low-budget sites that want to avoid duplicating data — but JSON-LD is just easier in practice. As of 2026, our analysis of top 1M websites shows 87% use JSON-LD for review schema, 11% microdata, 2% other or none. The handful of sites still using microdata are typically pre-2019 sites that have not been refactored. Our generator outputs JSON-LD by default.

What review count is needed to show stars in SERP?

No exact minimum, but practical observation: Google rarely shows stars for AggregateRating with fewer than 5 reviewCount, and reliably shows them at 10+. Below 5, the schema is parsed and indexed but the star snippet typically does not render. Above 50, the snippet is essentially guaranteed for eligible page types. The reviewCount also affects perceived trust: a "4.9 (3 reviews)" snippet looks weaker than "4.6 (248 reviews)" even though the rating is higher. Customers cluster on volume. Best practice for new products: wait until 5+ genuine reviews before adding AggregateRating schema. Adding schema with 1 review = 5.0 stars looks like cooked data and may attract Google attention. Once you reach 10+ reviews, the schema will likely render in SERPs. Above 200, the impact of additional reviews on CTR is marginal. Our generator warns when reviewCount is under 5 and suggests waiting before deploying.

How do I test my Review schema before deploying?

Use Google Rich Results Test (search.google.com/test/rich-results) — it is the definitive validator for whether Google will render your snippet. Paste either a URL or raw JSON-LD code. The tool reports: (1) Errors that prevent any rendering (missing required fields, invalid types). (2) Warnings about optional fields that improve display. (3) Preview of how the snippet might appear. Run it on every new schema deployment and on every existing page that uses review schema after a Google algorithm update. Schema.org Validator (validator.schema.org) is broader but not Google-specific. The Schema Markup Validator catches structural errors but Google has stricter requirements. For ongoing monitoring, use Google Search Console > Enhancements > Review snippets report — it tracks which pages have valid schema and which have errors. After deployment, snippets appear in SERPs typically within 7-14 days as Google recrawls and processes the page. Our Schema Rich Results Checker tool runs the same validation locally for instant feedback.

Can Review schema cause Google penalties?

Yes, in two ways. (1) Manual action: if Google determines your review schema is misleading (fake reviews, hidden reviews, self-promotional reviews on non-product pages), they may issue a manual penalty that removes ALL rich result eligibility for the entire site. Recovery requires removing the bad schema and submitting a reconsideration request — typically 30-90 days. (2) Algorithmic discount: if your schema produces statistically improbable ratings (5.0 across 10,000 reviews) or contradicts third-party sources, Google may algorithmically suppress your stars without a formal penalty. Less severe but still costly. Compliance basics: only mark up genuinely visible reviews on the page; do not aggregate reviews from disparate sources without attribution; do not mark up "self-reviews" of your own homepage; do not mark up reviews of competitors as if they were your reviews; do not mark up reviews you wrote yourself. Our generator includes a compliance check that flags any of these patterns before you deploy.

Does Review schema work for SaaS or service businesses?

Limited. Google removed eligibility for "Service" type review snippets in 2019 to combat self-promotional schema. SaaS companies generally do not get review stars in SERPs unless: (1) The page is specifically a SoftwareApplication type (Google still supports this) with proper categorization (applicationCategory: BusinessApplication, etc.). (2) The reviews are aggregated from third-party platforms (G2, Capterra, Trustpilot) with sameAs attribution. (3) The product is a sold software with pricing (rather than a generic SaaS subscription). For typical SaaS marketing pages, Review schema does not produce SERP stars. The alternative for SaaS: use Organization schema with aggregateRating to feed the Knowledge Panel (right side of branded SERPs), which Google does support. Or use FAQ schema to get featured-question rich snippets. Most SaaS companies put their review stars on G2 and Capterra (which have permission to show them in SERP) and link from their site rather than try to render them on their own pages. Our generator detects SaaS use case and recommends accordingly.

Free Review Schema Generator

Generate Review/AggregateRating JSON-LD for SERP star ratings. Free, instant, copy-paste ready.

4.6on G2

4.8on Trustpilot

Used by 25,000+ marketers

Item Reviewed

Item Type

Item URL

Item Name

Item Image (optional)

Brand (Product only, optional)

Review

Review Headline

Date Published

Review URL (optional)

Review Body

Rating

Rating Value

Best Rating

Worst Rating

Authorship

Author Type

Author Name

Include Publisher (editorial reviews)

JSON-LD Schema

{
  "@context": "https://schema.org",
  "@type": "Review",
  "itemReviewed": {
    "@type": "Product"
  },
  "reviewRating": {
    "@type": "Rating",
    "ratingValue": "4.5",
    "bestRating": "5",
    "worstRating": "1"
  },
  "author": {
    "@type": "Person"
  }
}

What this tool does

Review Schema Generator delivers fast, reliable results for generate review/aggregaterating json-ld for serp star ratings. free, instant, co.

Designed to fit into your existing SEO and content workflow with no setup overhead.

How to use it

Five steps.

Choose parent type

Select the page type — Product, LocalBusiness, SoftwareApplication, Recipe, Book, Course, or Event. Only these types are eligible for SERP star snippets.

Enter rating data

Provide ratingValue (e.g., 4.7), reviewCount, bestRating, and worstRating. Or connect to Trustpilot, G2, or Capterra for live data.

Add individual reviews (optional)

Paste in 5-10 individual customer reviews to mark up alongside AggregateRating. Improves on-page schema density and trust signals.

Generate JSON-LD

Output is copy-paste-ready JSON-LD wrapped in a script tag. Embed in your page head or body before closing </body>.

Validate and deploy

Test through Google Rich Results Test. Once green, deploy to production. SERP stars typically appear within 7-14 days as Google recrawls.

When teams use it

Six common workflows.

Add review stars to Shopify product pages

Generate JSON-LD with aggregateRating nested in Product schema. Drop into theme.liquid head section. Validates through Google Rich Results Test and starts rendering stars in SERP within 7-14 days.

Mark up local business reviews

Generate LocalBusiness + AggregateRating schema for your dentist, restaurant, or service-area business. Lifts Maps CTR 30-40% and complements Google Business Profile reviews.

Aggregate Trustpilot ratings into your site

Pull AggregateRating from Trustpilot API with proper sameAs attribution. SaaS marketing pages get review schema that Google trusts because the source is third-party verified.

Mark up recipe reviews on food blogs

Recipe schema is one of the few page types where Review schema reliably triggers SERP stars even on blog-style content. Generator includes Recipe parent type with all required fields.

Add software reviews to SaaS landing pages

SoftwareApplication schema with aggregateRating from G2 and Capterra. Generator pulls from G2 API directly when you provide your G2 product URL.

Validate existing review schema before audit

Schema deployed years ago may have aged out of Google requirements. Run our generator validation on existing pages and catch errors before they trigger algorithmic suppression.

Platform guides

Integrate with major platforms.

WordPress (Yoast)

Install Yoast SEO Premium or Schema Pro plugin.
Enable Review schema for the relevant page type.
Generate base schema from our tool for fields Yoast does not handle automatically.
Verify in Yoast settings that the AggregateRating is being injected.
Test the deployed page through Google Rich Results Test.

Shopify

Generate JSON-LD from our tool with Product as parent type.
In Shopify admin, navigate to Online Store > Themes > Edit code.
Open theme.liquid and paste the JSON-LD script in the head section, wrapped in {% if product %} ... {% endif %}.
Preview a product page and view source to confirm the script is rendered.
Run the page through Google Rich Results Test.

Webflow

Generate the schema with Product or relevant parent type.
In Webflow Designer, open Page Settings for the product or relevant template page.
Paste the script tag into Custom Code > Inside <head> tag.
Publish the site to staging.
Run the staging URL through Google Rich Results Test before pushing to production.

Next.js

Generate the schema and copy the JSON object.
In your page component, add a <script type="application/ld+json"> tag with dangerouslySetInnerHTML containing JSON.stringify(schemaObj).
For dynamic ratings, populate ratingValue and reviewCount from your data source.
Deploy and validate on production URL.
Set up Search Console > Enhancements monitoring to catch any regressions.

Trustpilot TrustBox

Sign up for Trustpilot Business and verify your domain.
Navigate to TrustBox library and select a widget that includes schema (e.g., Mini, Slider).
Customize and copy the embed code.
Paste into your page where you want the widget visible.
Trustpilot auto-injects AggregateRating schema in the page head with proper sameAs attribution.

Grigora vs. alternatives

Side-by-side.

Capability	Grigora	Schema App	Yoast SEO	Merkle Schema	Manual
JSON-LD output (recommended format)	Yes	Yes	Microdata only	Yes	Manual
AggregateRating + individual Review nesting	Yes	Aggregate only	Yes	Limited	Manual
Trustpilot / G2 / Capterra API integration	Yes	No	Trustpilot only	No	Manual
Compliance check for Google fake-review rules	Yes	No	No	Limited	No
All eligible parent types (Product, LB, etc.)	Yes	Product only	Yes	Limited	Manual
Free without signup	Yes	Trial only	No	Plan-capped	Yes
Validates against Google Rich Results spec	Yes	Yes	Yes	No	Manual
Multi-language review markup	Yes	No	Yes	No	Manual

Common errors and fixes

Eight issues users hit.

Google Rich Results Test reports "Missing field reviewCount"

Cause: AggregateRating included ratingValue but not reviewCount or ratingCount.

Fix: Add reviewCount (count of reviews with text) or ratingCount (count of star-only ratings). Google requires at least one of these for eligibility.

Schema validates but stars do not appear in SERP

Cause: Page type is not eligible for review snippets (e.g., generic blog page or homepage).

Fix: Verify your parent type is Product, LocalBusiness, SoftwareApplication, Recipe, Book, Course, MovieRated, or Event. Generic blog or service pages will not render stars regardless of valid schema.

Trustpilot ratings differ from on-page schema

Cause: Schema was hardcoded with old rating values that drifted from current Trustpilot reality.

Fix: Use a dynamic integration (Trustpilot TrustBox widget, our generator with API mode) that auto-updates schema when ratings change. Static schema needs quarterly manual updates.

Manual penalty for fake review schema

Cause: Google detected that on-page reviews did not exist or did not match the schema.

Fix: Remove all review schema from the affected pages. Wait 30-60 days. Submit reconsideration request via Google Search Console > Manual Actions. Re-add schema only for pages with genuine visible reviews.

Schema appears on every page including homepage

Cause: Theme or template injected schema globally instead of conditionally on product pages.

Fix: Modify the theme to inject Review schema only on product pages. Most modern themes have a conditional check (e.g., {% if product %} in Shopify Liquid) that gates schema to the right contexts.

Multiple Review schemas on same page conflict

Cause: Both individual Review schemas and AggregateRating present without proper itemReviewed nesting.

Fix: Nest individual Reviews inside the parent Product or LocalBusiness, alongside AggregateRating. Google handles multiple Reviews of the same item correctly when properly nested.

Best rating and worst rating wrong

Cause: AggregateRating rated on 1-10 scale but bestRating omitted, so Google assumed 5-point scale.

Fix: Always specify bestRating and worstRating explicitly when not using a 1-5 scale. Google may render stars correctly on a 10-point scale if bestRating: "10" is set.

Review schema breaks after CMS update

Cause: WordPress or Shopify theme update overwrote the custom schema injection in functions.php or theme.liquid.

Fix: Use a child theme for WordPress or duplicate theme for Shopify. Schema lives in your custom layer and survives parent theme updates.

Original data

2026 study.

+30-40%

CTR lift from review stars in SERP

10+

Minimum reviewCount for reliable star rendering

87%

Sites using JSON-LD vs microdata for schema

7-14 days

Time from deployment to SERP star rendering

Frequently asked questions

Twelve answers.

Related free tools

Other utilities.

Try Review Schema Generator now

Free, unlimited, no signup.

Try the Tool