Review Schema

TL;DR — Review schemaReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average. is code you add to a page that labels one person’s review of one thing — who wrote it, what it’s about, and the star rating they gave. Adding it correctly makes the page eligible for the star snippet you sometimes see in search results. It does not guarantee stars, it does not boost your ranking, and — the big one — you generally can’t use it to put stars on your own business by reviewing yourself.

What Review schema is

When a critic writes “I give this restaurant 4 out of 5 stars,” you can tell who’s talking, what they’re reviewing, and the score just by reading. A search engine sees plain text. Review schema — the schema.org/Review vocabulary — spells it out in code: this is the author, this is the thing being reviewed (itemReviewed), and this is the rating they gave (reviewRating).

It’s almost always written as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.: a small block of code that sits in the page without changing how the page looks. Evidence for this claim Schema.org Review represents a review of an item and can include an author, item reviewed, and rating. Scope: Schema.org vocabulary; Google supports review snippets only for documented item types and conditions. Confidence: high · Verified: 2026-07-14 Schema.org: Review

The key idea to hold onto: a Review is one critic, one write-up, one item. That’s different from an aggregate rating — an average built from many reviews (like “4.6 stars from 218 reviews”). Those are a separate type (AggregateRating), and the two are meant to work together, not as either/or.

The three things every Review needs

For a Review to be valid, Google needs three fields:

• author — a real name (a person or an organization). It has to be an actual name; something like “50% off until Saturday” is not a valid reviewer name and disqualifies the snippet.
• itemReviewed — what’s being reviewed (a book, a movie, a product, a recipe, a restaurant, and so on). One specific thing, not a category or a “top 10” list.
• reviewRating with a ratingValue — the score. The scale defaults to 1–5 unless you say otherwise. Evidence for this claim Google's review snippet documentation identifies required and recommended review properties and supported reviewed-item types. Scope: Google Search review snippet requirements; valid Schema.org Review markup can still be ineligible for Google stars. Confidence: high · Verified: 2026-07-14 Google: Review snippet structured data

The trap most people fall into

Here’s the mistake I see constantly: a business owner puts customer testimonials on their own homepage, marks them up with Review schema, and expects gold stars in Google. That doesn’t work. Google specifically blocks star snippets when a business is reviewing itself on its own site (this is the “self-serving reviews” rule). It applies to local businesses and organizations rating themselves — it does not block reviews of products, books, movies, recipes, or software.

Two more beginner truths:

• Valid markup ≠ guaranteed stars. It makes the page eligible; Google still decides whether to show them.
• Review schema never boosts ranking. At most it changes how your listing looks, which can earn more clicks — that’s it.

Want the full version — nested vs. standalone reviews, the exact self-serving rule, why your stars might not show, and the manual-action risk? Switch to the Advanced tab.

TL;DR — schema.org/Review marks up a single evaluation: one author, one itemReviewed, one reviewRating.ratingValue. Those three are required. If the Review is nested inside the reviewed item via the review property, omit itemReviewed — Google infers the parent — but still supply the item’s name. ratingValue defaults to a 1–5 scale unless you set bestRating/worstRating, and decimals use a dot, not a comma. The one rule that outranks all the others in importance: the self-serving-reviews restriction (Google’s September 2019 policy) makes LocalBusiness/Organization pages that carry reviews about themselves ineligible for the star feature — including reviews pulled in through an embedded third-party widget on your own site. That carve-out is scoped to business/organization items only; Product, Book, Movie, Recipe, SoftwareApplication, Event, Course, Game and friends are not restricted. Valid markup earns rich-result eligibility, never a ranking boost, and violations can draw a manual action. Whether you came here for the pure structured-data angle or the ecommerce-review angle, both live in the same place — this topic is cross-listed under structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. and under ecommerce SEOEcommerce SEO is the practice of optimizing an online store so its product and category pages rank in organic search and attract purchase-intent visitors. It uses the same Google algorithm as any other site, but compounds the usual SEO work with commerce-specific challenges like faceted navigation, product variants, and platform-imposed URLs. for that reason.

Review vs. AggregateRating — get this straight first

Almost every mistake downstream starts with conflating these two types:

• Review — one critic or user, one item, one rating. A single write-up.
• AggregateRating — a numeric summary of many reviews or ratings (an average plus a count).

Google’s docs bundle both on one page — “Review snippet (Review, AggregateRating) structured data” — because they render the same star UI. But the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. types and their eligibility rules diverge, and the required fields differ. Crucially, they’re meant to be used together: Google’s guidance is that “if you include multiple individual reviews, also include an aggregate rating of the individual reviews.” So the decision isn’t Review or AggregateRating — it’s “one write-up → Review,” “an average across many → AggregateRating,” and “a page full of reviews → both.” That guidance runs one direction only: a single Review doesn’t need a fabricated aggregate bolted on to look more credible, and an AggregateRating doesn’t require you to invent individual reviews to back it — pair the two only when both genuinely exist. The AggregateRating side of this gets its own treatment in the sibling article; here I’m strictly on the single Review object.

The required core: author, itemReviewed, reviewRating

Three properties are required for a Review, per Google’s required-properties table on the review-snippet doc (checked 2026-07-18; the doc itself shows a last-updated date of 2025-12-10, so this reflects the current version).

author — a Person or Organization. Google is explicit that “the reviewer’s name must be a valid name” and gives the memorable counter-example: “‘50% off until Saturday’ is not a valid name for a reviewer.” The name must be shorter than 100 characters, or the page “won’t be eligible for an author-based review snippet.” Promotional strings dressed up as reviewer names are a real, common disqualifier.

itemReviewed — one of the valid types, “the item that is being reviewed.” This is where the single-item scoping bites: Google wants you to “provide review information about a specific item, not about a category or a list of items.” A “Top 10 Best Blenders” roundup that wraps one Review around the whole list is malformed — each product needs its own review, or the page needs a different treatment.

reviewRating (a Rating) with reviewRating.ratingValue — the score. For a single Review this is normally a plain Rating, not an AggregateRating (that distinction trips people up because Google’s shared doc mentions AggregateRating as a possible subtype). The value can be “a number, fraction, or percentage (for example, 4, 60%, or 6 / 10).” Two formatting rules people miss:

• The default scale is 1–5 (1 lowest, 5 highest). If your scale is different, set bestRating and worstRating.
• Decimals use a dot, not a comma — 4.4, never 4,4, regardless of your locale’s display convention.

Recommended (not required): datePublished (ISO 8601), and reviewRating.bestRating / worstRating. If bestRating is omitted, 5 is assumed; if worstRating is omitted, 1 is assumed.

Where Review schema is supported

Review is broader than most people assume. Google supports it for Book, Course, Event, LocalBusiness (with the self-serving caveat below), Movie, Product, Recipe, and SoftwareApplication — plus their subtypes and several more: CreativeWorkSeason, CreativeWorkSeries, Episode, Game, MediaObject, MusicPlaylist, MusicRecording, and Organization (again, with the self-serving caveat). HowTo is also a valid itemReviewed type per Google’s current property reference — worth a check if you’re reviewing tutorials or instructional content, since it’s easy to miss in the prose list of “supported for” types. Evidence for this claim Google limits review snippet eligibility to specific Schema.org types and applies additional content and policy rules. Scope: Google Search review snippet feature; Schema.org validity alone is insufficient. Confidence: high · Verified: 2026-07-14 Google: Review snippet structured data So a critic reviewing a film, a user reviewing a recipe, or an editor reviewing a software app are all textbook, unrestricted uses.

Nested vs. standalone — when to omit itemReviewed

There are two shapes:

• Standalone Review — a top-level Review that carries itemReviewed naming what it’s about. This is the “critic review” pattern (one journalist/publisher, one thing, one rating).
• Nested Review — a Review placed inside the reviewed entity via the review property (e.g., a Game with a "review": {…} block). Here Google says to omit itemReviewed: “if the review is nested into another schema.org type using the review property, omit the itemReviewed property (we assume the parent item is the reviewed item).” The parent item’s name isn’t just good practice here — Google’s own required-properties table lists itemReviewed.name as its own required row, so a nested Review with an unnamed parent is missing a required field, not just missing context.

Getting this wrong — supplying itemReviewed inside a nested review, or omitting it on a standalone one — is one of the most common Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test failures in this space, and one that generic guides rarely walk through.

The self-serving-reviews rule — the single most important restriction

This is the rule to internalize, because it’s where the old “testimonials as review schema” tactic died and it’s the thing competitor guides most often bury.

Google, on the review-snippet doc: “If the entity that’s being reviewed controls the reviews about itself, their pages that use LocalBusiness or any other type of Organization structured data are ineligible for star review feature.” And the example is unambiguous: “a review about entity A is placed on the website of entity A, either directly in their structured data or through an embedded third-party widget (for example, Google Business reviews or Facebook reviews widget).”

Read carefully what this does — and doesn’t — cover:

• It’s scoped to LocalBusiness / Organization items being reviewed. A business or organization rating itself on its own pages gets no stars. That includes embeddingEmbeddings are dense numerical vectors — lists of floating-point numbers — that represent the meaning of text in a high-dimensional space. Semantically similar content lands close together, so search and AI systems can match by meaning, not just keywords. a third-party review widget (Google Business Profile, Facebook) on your own site — the source being external doesn’t rescue it if the entity controls the page. Evidence for this claim Google excludes self-serving reviews for LocalBusiness and Organization from the star review feature. Scope: Google Search review snippet policy; this restriction is scoped and should not be generalized to every reviewed type. Confidence: high · Verified: 2026-07-14 Google: Review snippet structured data
• It does not cover Product, Book, Movie, Recipe, SoftwareApplication, Event, Course, Game, etc. Reviewing those on your own site is fine. Don’t overstate the policy’s scope — the frequent mangling is “Google killed review stars,” when the ban is specifically about self-hosted business/organization reviews.

One thing worth being blunt about, since it’s not spelled out verbatim in Google’s docs and I don’t want to overstate the sourcing: relabeling the reviewed entity as a Product or some other unrestricted type, when what’s actually being reviewed is your own business, isn’t a documented workaround. The restriction is written around what’s actually being reviewed and who controls the page it’s reviewed on — not the @type string you choose to declare. Treat this as editorial judgment, not a quoted policy: mislabeling the entity to dodge the rule is the kind of thing a manual reviewer is specifically looking for.

Google also draws two adjacent lines: “Ratings must be sourced directly from users,” and “Don’t rely on human editors to create, curate, or compile ratings information for local businesses.” And a flat rule that applies broadly: you can’t scrape ratings from elsewhere — “Don’t aggregate reviews or ratings from other websites.” Copying Yelp or Google stars onto your own page and marking them up as yours is out.

The policy dates to roughly September 2019; Google announced it in a Search Central post on making review rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. more helpful. I’ll be honest about the sourcing: I couldn’t verify a clean, pinned Mueller or Illyes quote specifically on the self-serving-review manual-action mechanic, so I’m citing the docs and the policy announcement rather than putting words in anyone’s mouth (see the Quotes tab).

Eligibility, not ranking — and the manual-action risk

Two framing points that matter:

• Review markup earns rich-result eligibility, not a ranking boost. The best case is a critic review snippet — stars and summary text in the listing. That can lift click-through, but it does not move you up the results. Any guide promising a “15–35% CTR lift” from review schemaReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average. is quoting an unverifiable stat; treat it with suspicion.
• Violations can trigger a manual action. Google warns: “If your site violates one or more of these guidelines, then Google may take manual action against it. Once you have remedied the problem, you can submit your site for reconsideration.” Google’s General Structured Data Guidelines spell out the precise consequence: “A structured data manual action means that a page loses eligibility for appearance as a rich result; it doesn’t affect how the page ranks in Google web search.” So the penalty is scoped to the rich result, not the page’s ordinary ranking — you lose the snippet until you fix the violation and request reconsideration, but you don’t get demoted or deindexed for it.

It helps to keep six separate states straight, because “it validated” and “it shows stars” are not the same fact: passing the Rich Results Test (field presence) → Google supporting the itemReviewed type at all → the page being eligible under the guidelines (not self-serving, not scraped, visible content) → Google having actually indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. the page → Google choosing to display the snippet → and — entirely separate from all of the above — the page’s ranking. A page can be green across the first five and still not rank well, and a page can rank well while never showing a single star.

Also remember the visibility rule: the reviews you mark up must be genuinely on the page and obvious to users — “it must be immediately obvious to users that the page has review content.” Marked-up reviews that a visitor can’t actually see are a guideline violation, not just a validation nit.

Testing and monitoring

Validate the markup with the Rich Results Test, then watch Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results.. Google added a dedicated review-snippets report in Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. (2020) that flags which pages are eligible and which have errors — that’s the diagnostic to check after you ship, since the Rich Results Test confirms field presence but not policy compliance (it won’t tell you your self-hosted business review is ineligible).

Bing and other engines

Bing’s structured-data guidance is much thinner than Google’s. Bing supports marking up reviews and ratings with schema.org vocabulary and will recognize it for enhanced results, and it validates annotated data against the declared type and expected format (mismatches get ignored rather than hard-rejected). But Bing has not published an equivalent to Google’s 2019 self-serving-reviews crackdown — there’s no Bing-specific Review eligibility page comparable to Google’s. Practically: treat Google’s Review/AggregateRating doc as the de facto standard even for Bing-focused work, because Bing points back to the same schema.org vocabulary without adding its own restrictions.

For where Review fits in the wider picture, it sits alongside the AggregateRating, Product, and Organization schemaOrganization schema (schema.org/Organization) is structured data that describes the business or entity itself — name, logo, official URL, social profiles, contact info, and identifiers — rather than a page's content. Google says it can help disambiguate your brand and some properties can influence visual elements like Knowledge Panel/attribution; it has no required properties and doesn't guarantee a Knowledge Panel. siblings under the broader structured-data hub this article nests within.

AI summary

A condensed take on the Advanced version:

• What it is: schema.org/Review markup (usually JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.) for a single evaluation — one author, one itemReviewed, one reviewRating — as opposed to AggregateRating, which averages many reviews.
• Required core: author (a valid person/org name under 100 chars — “50% off until Saturday” is not a name), itemReviewed (one specific item, not a category or list), and reviewRating.ratingValue.
• Rating format: default scale 1–5; set bestRating/worstRating for other scales; decimals use a dot (4.4), not a comma. datePublished, bestRating, worstRating are recommended.
• Nested vs. standalone: standalone Review carries itemReviewed; a Review nested inside the reviewed type via the review property omits itemReviewed (Google infers the parent) but still needs the parent’s name.
• Supported items: Book, Course, Event, Movie, Product, Recipe, SoftwareApplication, Game, Organization, LocalBusiness, HowTo, and more.
• Self-serving rule (the big one): scoped to LocalBusiness/Organization reviewing itself on its own site (including embedded third-party widgets) — those are ineligible for stars. Product/Book/Movie/Recipe/SoftwareApplication etc. are not restricted. Don’t overstate scope — and relabeling the entity as a different @type isn’t a documented workaround.
• Don’t-do list: no scraped/aggregated ratings from other sites; ratings must be user-sourced; reviews must be genuinely visible on the page; don’t pair a single Review with a fabricated aggregate or invent reviews to back an aggregate.
• Eligibility ≠ ranking: best case is a critic review snippet; never a ranking boost. Beware unverifiable “15–35% CTR lift” claims. Validator-pass, Google-support, eligibility, visibility, display, and ranking are six separate states — green on one doesn’t mean green on the rest.
• Enforcement: violations can trigger a manual action. Per Google’s own wording, that “means that a page loses eligibility for appearance as a rich result; it doesn’t affect how the page ranks in Google web search” — until fixed and reconsideration is requested.
• Testing: Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test for field presence; Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. review-snippets report for eligibility/errors. Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test does not check policy compliance.
• Bing: supports schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. review markup but has no equivalent self-serving policy; treat Google’s doc as the standard.

Official documentation

Primary-source documentation from the search engines and schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor..

Google — Review snippets

• Review snippet (Review, AggregateRating) structured data — the authoritative reference: required/recommended properties, supported itemReviewed types, the nested-vs-standalone rule, and the self-serving-reviews restriction. Checked live 2026-07-18; the page itself shows “Last updated 2025-12-10 UTC.”
• Making Review Rich Results more helpful (2019) — the announcement of the self-serving-reviews policy for organizations/local businesses.
• New reports for review snippets in Search Console (2020) — the diagnostic report for eligibility and errors after implementation.
• General Structured Data Guidelines — the spammy-structured-data / manual-action policy.
• Rich Results Test — validate the markup (field presence, not policy compliance).

Bing / Microsoft

• Marking up your site with structured data — Bing’s general structured-data support (schema.org, JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. recommended).

schema.org

• Review — the type definition and full property list.
• AggregateRating — the companion type for many-reviews summaries.

Quotes from the source

On-the-record statements from Google’s documentation. Where the source page exposes the text, the link is a deep link that jumps to the quoted passage.

Google docs — what a review snippet is

• “A review snippet is a short excerpt of a review or a rating from a review website, usually an average of the combined rating scores from many reviewers.” Jump to quote

Google docs — required properties

• On the reviewer name: “The reviewer’s name must be a valid name. For example, ‘50% off until Saturday’ is not a valid name for a reviewer.” Jump to quote
• On omitting itemReviewed when nested: “However, if the review is nested into another schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. type using the review property, omit the itemReviewed property.” Jump to quote
• On the rating scale: “The default scale for numbers is a 5-point scale, where 1 is the lowest value and 5 is the highest value.” Jump to quote

Google docs — the self-serving-reviews rule

• “If the entity that’s being reviewed controls the reviews about itself, their pages that use LocalBusiness or any other type of Organization structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. are ineligible for star review feature.” Jump to quote

Google docs — don’t aggregate from other sites

• “Don’t aggregate reviews or ratings from other websites.” Jump to quote

Google docs — manual-action warning

• “Warning: If your site violates one or more of these guidelines, then Google may take manual action against it.” Jump to quote
• On what the manual action actually costs you, from Google’s General Structured Data Guidelines: “A structured data manual action means that a page loses eligibility for appearance as a rich result; it doesn’t affect how the page ranks in Google web search.” Jump to quote

Review schema myths and mistakes to avoid

Myth: “Review schemaReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average. guarantees stars in Google.” It only makes the page eligible. The review content must be genuinely visible on the page, the guidelines must be satisfied, and Google still decides discretionarily whether to render the snippet. Valid ≠ displayed — and it never means a ranking boost.

Myth: “I can put customer testimonials with Review schema on my own business homepage and get stars.” This is the #1 myth to bust. The self-serving-reviews rule makes LocalBusiness/Organization pages that carry reviews about themselves ineligible for the star feature — “if the entity that’s being reviewed controls the reviews about itself… ineligible for star review feature.” EmbeddingEmbeddings are dense numerical vectors — lists of floating-point numbers — that represent the meaning of text in a high-dimensional space. Semantically similar content lands close together, so search and AI systems can match by meaning, not just keywords. a third-party widget (Google Business Profile, Facebook) on your own site doesn’t rescue it.

Myth: “The self-serving ban killed review stars everywhere.” No — don’t overstate the scope. The restriction is scoped to LocalBusiness/Organization items. Reviews of Products, Books, Movies, Recipes, Software Apps, Events, Courses, and Games are not subject to it.

Myth: “Review and AggregateRating are interchangeable — just use whichever my plugin defaults to.” Review = one critic, one write-up; AggregateRating = a summary number across many. Conflating them muddies both the schema (missing required fields) and the content (a single testimonial dressed up as an “aggregate” of one). Google’s steer is to use them together when a page has multiple reviews.

Mistake: omitting itemReviewed on a standalone Review — or including it on a nested one. A top-level Review needs itemReviewed; a Review nested via the review property must omit it (Google infers the parent). Getting this backwards is a classic Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test failure.

Mistake: a promotional string as the reviewer name. “‘50% off until Saturday’ is not a valid name for a reviewer,” and names over 100 characters disqualify the author-based snippet. Use a real person or organization name.

Mistake: wrapping one Review around a “Top 10” list. Reviews must be about a specific item, not a category or list. Each product on a roundup needs its own review, or a different treatment.

Mistake: scraping or aggregating other sites’ ratings. “Don’t aggregate reviews or ratings from other websites.” Copying Yelp/Google stars onto your page and marking them up as yours is a violation.

Mistake: marked-up reviews that users can’t actually see. The review content must be “immediately obvious to users” on the page. Hidden or fabricated reviews are a guideline breach that can draw a manual action — which suppresses your markup for rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. until you remediate and request reconsideration.

Mistake: comma decimals or non-1–5 scales without bounds. Use a dot (4.4, not 4,4), and set bestRating/worstRating if your scale isn’t the default 1–5.

Clean vs. broken Review JSON-LD

A clean standalone critic review

One publisher, one item, one rating — the textbook “critic review” pattern with an explicit itemReviewed:

{
  "@context": "https://schema.org/",
  "@type": "Review",
  "itemReviewed": {
    "@type": "Restaurant",
    "name": "Legal Seafood",
    "servesCuisine": "Seafood",
    "priceRange": "$$$"
  },
  "reviewRating": {
    "@type": "Rating",
    "ratingValue": 4,
    "bestRating": 5,
    "worstRating": 1
  },
  "author": {
    "@type": "Person",
    "name": "Bob Smith"
  },
  "datePublished": "2026-05-12",
  "publisher": {
    "@type": "Organization",
    "name": "Washington Times"
  }
}

A clean nested review (itemReviewed omitted)

When the Review lives inside the reviewed item via the review property, drop itemReviewed — the parent’s name supplies the context:

{
  "@context": "https://schema.org/",
  "@type": "Movie",
  "name": "The Great Escape",
  "review": {
    "@type": "Review",
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": 5
    },
    "author": {
      "@type": "Person",
      "name": "Jane Doe"
    }
  }
}

The same standalone review, broken

Every flagged line below is a real, common failure:

{
  "@context": "https://schema.org/",
  "@type": "Review",
  "reviewRating": {
    "@type": "Rating",
    "ratingValue": "4,5",
    "bestRating": "10"
  },
  "author": {
    "@type": "Person",
    "name": "50% off until Saturday"
  }
}

What’s wrong:

• No itemReviewed — a standalone Review must name what it reviews (only a nested review omits it). Missing it means Google has no item to attach stars to.
• "name": "50% off until Saturday" — a promotional string, not a valid reviewer name; explicitly disqualifies the author-based snippet.
• "ratingValue": "4,5" — comma decimal. Use a dot: "4.5".
• bestRating: "10" with no worstRating — if you use a non-default scale, declare both bounds so the rating is interpreted correctly.

Where the markup can be valid but still ineligible

This one passes the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test yet earns no stars, because of the self-serving rule — a business reviewing itself on its own site:

{
  "@context": "https://schema.org/",
  "@type": "LocalBusiness",
  "name": "Acme Plumbing",
  "review": {
    "@type": "Review",
    "reviewRating": { "@type": "Rating", "ratingValue": 5 },
    "author": { "@type": "Person", "name": "A Happy Customer" }
  }
}

The fields are all present, so validation is green — but because Acme controls the page and the reviewed entity is its own LocalBusiness, it’s ineligible for the star feature. This is exactly the gap the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test can’t catch: it checks field presence, not policy compliance.

Nested or standalone — where does itemReviewed go?

The single most common Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test failure in this space is getting the nested-vs-standalone shape backwards. Walk the branch before you ship:

Common issues: markup validates but stars don’t show

Symptom: Rich Results Test passes, but no stars appear in search results

Likely cause: the self-serving-reviews rule — the reviewed item is a LocalBusiness/Organization and the page is on that same entity’s own site (including an embedded third-party review widget). Also possible: Google is simply exercising discretion (eligible ≠ guaranteed), or the review content isn’t genuinely visible to users on the page.

Fix: check whether itemReviewed is LocalBusiness/Organization and whether the page belongs to that same entity — if so, there’s no markup fix; the restriction is by design. If the item type isn’t restricted, confirm the review text is actually visible on the rendered page, then check the Search Console review-snippets report for the stated eligibility reason. Confirm worked: the report shows the page as eligible with no errors.

Symptom: Rich Results Test flags “itemReviewed” as missing or unexpected

Likely cause: a standalone Review is missing itemReviewed, or a nested Review (inside the reviewed item’s review property) has itemReviewed added when it should be omitted.

Fix: for a standalone Review, add itemReviewed naming one specific item. For a nested Review, delete itemReviewed — Google infers the parent. Confirm worked: re-run the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test and check the field is recognized correctly for the shape you used.

Symptom: Author-based review snippet doesn’t appear

Likely cause: the reviewer name is a promotional string (Google’s own example: “50% off until Saturday”) or exceeds 100 characters.

Fix: replace the author.name with a real person or organization name under 100 characters. Confirm worked: the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test no longer flags the author field.

Symptom: ratingValue is ignored or misread

Likely cause: a comma decimal ("4,5" instead of "4.5"), or a non-default scale used without declaring bestRating/worstRating.

Fix: use a dot for decimals, and set bestRating/worstRating whenever the scale isn’t the default 1–5. Confirm worked: the Rich Results Test parses the rating value and scale as expected.

Symptom: markup was working, then rich results disappeared site-wide

Likely cause: a manual action for violating the structured-data guidelines (scraped/aggregated ratings from other sites, hidden reviews, or self-serving reviews).

Fix: review the General Structured DataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. Guidelines, remove the violating content or markup, and submit for reconsideration. Per Google’s own wording, the manual action costs you rich-result eligibility only — “it doesn’t affect how the page ranks in Google web search” — so the fix restores the snippet, not your rankings (you never lost those). Confirm worked: the manual-action notice in Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. clears and the review-snippets report shows eligible pages again.

Review schema audit checklist

• author is present and is a real Person or Organization name — not a promotional string — and under 100 characters.
• itemReviewed is present on standalone Reviews, naming one specific item (not a category or a “Top 10” list).
• itemReviewed is omitted on Reviews nested inside the reviewed item via the review property — and the parent item still carries its own name.
• reviewRating is present with a ratingValue.
• ratingValue uses a dot for decimals (4.5, never 4,5).
• If the scale isn’t the default 1–5, both bestRating and worstRating are set.
• datePublished is included (recommended, ISO 8601 format).
• Confirm itemReviewed’s type isn’t LocalBusiness or Organization being reviewed on that same entity’s own site (including via an embedded third-party widget) — if it is, the page is ineligible for stars regardless of valid markup.
• Confirm reviews aren’t scraped or aggregated from another website.
• Confirm the review content is genuinely and immediately visible to users on the page itself.
• Run the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test to confirm field presence, then check the Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. review-snippets report for eligibility and errors.

Review schema at a glance

Required vs. recommended properties

Self-serving-reviews scope — who’s restricted

Review vs. AggregateRating

Validate the markup after you ship

Test 1: Field-presence validation

Test to run: paste the page URL or JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. into Google’s Rich Results Test. Expected result: the Review item is detected with no errors, and author, itemReviewed (if standalone), and reviewRating.ratingValue all parse correctly. Failure interpretation: a flagged/missing field means required markup is absent or malformed — check the nested-vs-standalone shape and the author-name rules first. Monitoring window: immediate — this is a point-in-time structural check, not a live-search signal. Rollback trigger: if errors persist after fixing the obvious fields, re-check whether itemReviewed was added to (or omitted from) the wrong shape.

Test 2: Eligibility over time

Test to run: the review-snippets report in Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results.. Expected result: affected pages show as “Valid” / eligible, with an increasing eligible-page count and no new errors. Failure interpretation: pages showing eligible-but-not-displaying stars is expected if itemReviewed is LocalBusiness/Organization on your own site (the self-serving rule) — that’s not a markup bug. Pages showing errors need the specific field the report names fixed. Monitoring window: allow at least one to two weeks for Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. to recrawlCrawl frequency is how often a search engine comes back to re-fetch a page it already knows about. Popular pages that change often get refreshed many times a day; stable pages can go weeks or months between crawls — and you influence it indirectly, not by setting a dial. and reprocess before treating the report as trustworthy. Rollback trigger: a rising error count, or a manual-action notice appearing in Search Console.

Test 3: On-page visibility check

Test to run: manually view the live, rendered page and confirm the exact review text and rating being marked up is visible to a normal visitor. Expected result: the review content is immediately obvious on the page — not hidden, collapsed behind a script, or absent entirely. Failure interpretation: markup describing content a visitor can’t actually see is a guideline violation, not just a validation nit, and can suppress rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. independent of whether the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. itself is well-formed. Monitoring window: check immediately after publishing and again after any template or CSS change that could hide the content. Rollback trigger: the review text is not visible without extra interaction (an accordion default-collapsed, content behind a login, etc.).

Test yourself: Review Schema

Five quick questions on schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Review, its required fields, and the self-serving rule. Pick an answer for each, then check.

Resources worth your time

My writing on this topic

I haven’t published a standalone Review schemaReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average. guide of my own, and I’d rather tell you that than point you at something that doesn’t exist. For the broader vocabulary and where Review fits, lean on the primary sources below and the related structured-data work on this site — the AggregateRating, Product, and Organization schema siblings, plus the wider Schema MarkupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and Structured DataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. hubs this article nests under.

From the source

• Review snippet (Review, AggregateRating) structured data (Google Search Central) — the authoritative reference for required/recommended properties, supported types, nested-vs-standalone, and the self-serving-reviews rule.
• Making Review Rich Results more helpful (Google, 2019) — the origin of the self-serving-reviews policy.
• New reports for review snippets in Search Console (Google, 2020) — the post-implementation diagnostic report.
• General Structured Data Guidelines (Google) — the spammy-structured-data / manual-action policy.
• Review (schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor.) — the type definition and full property list.
• Marking up your site with structured data (Bing) — Bing’s general structured-data support.

Review Schema

Review schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average.

Related: AggregateRating Schema, Product Schema, Organization Schema, Schema Markup, Structured Data, Rich Results

Review Schema

Review is the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. type used to mark up a single critic’s or user’s evaluation of one specific item. Every Review has three required parts: an author (a real person or organization), an itemReviewed (what’s being reviewed — a Book, Movie, Product, Recipe, SoftwareApplication, LocalBusiness, and so on), and a reviewRating carrying a ratingValue. It’s the atomic building block of the review-snippet family: it can stand alone as a critic review, or nest inside the reviewed item via the review property (in which case you omit itemReviewed because Google infers the parent).

It is distinct from AggregateRating, which is a numeric summary of many reviews or ratings. Review = one write-up; AggregateRating = an average across many. Google’s own docs bundle both under one “Review snippet” page because they render the same star UI, but the schema types and eligibility rules diverge.

The most-missed rule: the self-serving-reviews restriction — introduced by Google in September 2019 — is scoped to LocalBusiness/Organization items being reviewed on their own site. A business can’t mark up reviews about itself on its own pages and earn stars. Reviews of Books, Movies, Products, Recipes, Software Apps, and the like are not subject to that carve-out. Like all structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding., valid Review markup only earns rich-result eligibility (a critic review snippet), never a ranking boost — and self-serving or fabricated reviews can trigger a manual action.

Related: AggregateRating Schema, Product Schema, Organization Schema, Schema Markup, Structured Data, Rich Results

Changelog