Examiner Schema

TL;DR — Examiner schema is code vous ajouter to une page que étiquettes un person’s examiner of un chose — who wrote it, ce que it’s à propos de, and the star rating ils gave. Ajout it correctement rend lune page eligible pour the star snippet vous parfois voir in résultats de recherche. It fait pas guarantee stars, it fait pas boost votre ranking, and — the big un — vous généralement can’t utiliser it to put stars on votre propre business by reviewing yourself.

Ce que Examiner schema is

Quand a critic writes “I give this restaurant 4 out of 5 stars,” vous pouvez tell who’s talking, ce que they’re reviewing, and the score simplement by reading. A moteur de recherche sees plain text. Examiner schema — the schema.org/Examiner vocabulary — spells it out in code: ce is the author, ce is the chose being reviewed (itemReviewed), and ce is the rating ils gave (reviewRating).

It’s almost toujours written as JSON-LD: a petit block of code que sits in the page sans modification how lune page semble. 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 clé idea to hold onto: a Review is un critic, un write-up, un item. That’s différent from an aggregate rating — an average construit from nombreux reviews (comme “4.6 stars from 218 reviews”). Ceux are a separate type (AggregateRating), and the two are meant to fonctionner ensemble, pas as soit/or.

The three choses every Examiner nécessite

Pour a Examiner to be valid, Google nécessite three fields:

• author — a réel nom (a person or an organization). It has to be an réel nom; something comme “50% off until Saturday” n’est pas a valid reviewer nom and disqualifies the snippet.
• itemReviewed — what’s being reviewed (a book, a movie, a product, a recipe, a restaurant, and so on). Un spécifique chose, pas a category or a “top 10” liste.
• reviewRating with a ratingValue — the score. The scale defaults to 1–5 unless vous dire sinon. 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 la plupart personnes fall into

Here’s the mistake I voir constantly: a business owner puts customer testimonials on leur propre homepage, marks les up with Examiner schema, and expects gold stars in Google. Que doesn’t fonctionner. Google specifically blocks star snippets quand a business is reviewing itself on its propre site (ce is the “self-serving reviews” rule). It s’applique to local businesses and organizations rating themselves — it fait pas block reviews of products, books, movies, recipes, or software.

Two plus beginner truths:

• Valid markup ≠ guaranteed stars. It rend lune page eligible; Google encore decides si to montrer les.
• Examiner schema jamais boosts ranking. At la plupart it changements how votre listing semble, qui peut earn plus clicks — that’s it.

Vouloir the complet version — nested vs. standalone reviews, the exact self-serving rule, pourquoi votre stars pourrait pas montrer, and the manual-action risk? Switch to the Avancé tab.

TL;DR — schema.org/Review marks up a unique evaluation: un author, un itemReviewed, un reviewRating.ratingValue. Ceux three are requis. Si the Examiner is nested à l’intérieur the reviewed item via the review property, omit itemReviewed — Google infers the parent — but encore supply the item’s name. ratingValue defaults to a 1–5 scale unless vous définir bestRating/worstRating, and decimals utiliser a dot, pas a comma. The un rule que outranks tout the others in importance: the self-serving-reviews restriction (Google’s September 2019 policy) rend LocalBusiness/Organization pages que carry reviews à propos de themselves ineligible pour the star fonctionnalité — notamment reviews pulled in via an embedded third-party widget on votre propre site. Que carve-out is scoped to business/organization items seulement; Product, Book, Movie, Recipe, SoftwareApplication, Event, Course, Game and friends are pas restricted. Valid markup earns rich-result eligibility, jamais a ranking boost, and violations peut draw a manual action. Si vous came ici pour the pure structured-data angle or the ecommerce-review angle, les deux live in the même placer — ce topic is cross-listed sous données structurées and sous ecommerce SEO pour que raison.

Examiner vs. AggregateRating — obtenir ce straight premier

Almost every mistake downstream starts with conflating ces two types:

• Review — un critic or utilisateur, un item, un rating. A unique write-up.
• AggregateRating — a numeric summary of nombreux reviews or ratings (an average plus a count).

Google’s docs bundle les deux on un page — “Examiner snippet (Examiner, AggregateRating) données structurées” — parce que ils render the même star UI. But the schema.org types and leur eligibility rules diverge, and the requis fields differ. Crucially, they’re meant to be utilisé ensemble: Google’s guidance is que “si vous inclure multiple individual reviews, aussi inclure an aggregate rating of the individual reviews.” So the decision isn’t Review or AggregateRating — it’s “un write-up → Examiner,” “an average à travers nombreux → AggregateRating,” and “une page complet of reviews → les deux.” Que guidance runs un direction seulement: a unique Examiner doesn’t besoin a fabricated aggregate bolted on to regarder plus credible, and an AggregateRating doesn’t exiger vous to invent individual reviews to back it — pair the two seulement quand les deux genuinely exist. The AggregateRating side of ce obtient its propre treatment in the sibling article; ici I’m strictly on the unique Review object.

The requis core: author, itemReviewed, reviewRating

Three properties are requis pour a Review, per Google’s required-properties table on the review-snippet doc (vérifié 2026-07-18; the doc itself montre a last-updated date of 2025-12-10, so ce reflects the current version).

author — a Person or Organization. Google is explicit que “the reviewer’s nom doit be a valid nom” and donne the memorable counter-example: “‘50% off until Saturday’ is not a valid name for a reviewer.” The nom doit be shorter que 100 characters, or lune page “won’t be eligible pour an author-based examiner snippet.” Promotional strings dressed up as reviewer noms are a réel, courant disqualifier.

itemReviewed — un of the valid types, “the item that is being reviewed.” Ce is où the single-item scoping bites: Google veut vous to “provide examiner information à propos de a spécifique item, pas à propos de a category or a liste of items.” A “Top 10 Meilleur Blenders” roundup que wraps un Review autour the whole liste is malformed — chaque product nécessite its propre examiner, or lune page nécessite a différent treatment.

reviewRating (a Rating) with reviewRating.ratingValue — the score. Pour a unique Examiner ce is normally a plain Rating, pas an AggregateRating (que distinction trips personnes up parce que Google’s shared doc mentions AggregateRating as a possible subtype). The valeur peut be “a number, fraction, or percentage (pour exemple, 4, 60%, or 6 / 10).” Two formatting rules personnes miss:

• The par défaut scale is 1–5 (1 lowest, 5 highest). Si votre scale is différent, définir bestRating and worstRating.
• Decimals utiliser a dot, pas a comma — 4.4, jamais 4,4, regardless of votre locale’s afficher convention.

Recommended (pas requis): datePublished (ISO 8601), and reviewRating.bestRating / worstRating. Si bestRating is omitted, 5 is assumed; si worstRating is omitted, 1 is assumed.

Où Examiner schema is pris en charge

Examiner is broader que la plupart personnes assume. Google supports it pour Book, Course, Event, LocalBusiness (with the self-serving caveat ci-dessous), Movie, Product, Recipe, and SoftwareApplication — plus leur subtypes and several plus: CreativeWorkSeason, CreativeWorkSeries, Episode, Game, MediaObject, MusicPlaylist, MusicRecording, and Organization (à nouveau, with the self-serving caveat). HowTo is aussi a valid itemReviewed type per Google’s current property référence — worth a vérifier si you’re reviewing tutorials or instructional content, since it’s facile to miss in the prose liste 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 utilisateur reviewing a recipe, or an editor reviewing a software app are tout textbook, unrestricted uses.

Nested vs. standalone — quand to omit itemReviewed

Là are two shapes:

• Standalone Examiner — a top-level Review que carries itemReviewed naming ce que it’s à propos de. Ce is the “critic review” pattern (un journalist/publisher, un chose, un rating).
• Nested Examiner — a Review placed à l’intérieur the reviewed entity via the review property (e.g., a Game with a "review": {…} block). Ici Google dit to omit itemReviewed: “si the examiner is nested into un autre schema.org type en utilisant the examiner property, omit the itemReviewed property (we assume the parent item is the reviewed item).” The parent item’s name isn’t simplement bon pratique ici — Google’s propre required-properties table listes itemReviewed.name as its propre requis row, so a nested Examiner with an unnamed parent is manquant a requis field, pas simplement manquant context.

Getting ce incorrect — supplying itemReviewed à l’intérieur a nested examiner, or omitting it on a standalone un — is un of the la plupart courant Résultats enrichis Tester échecs in ce space, and un que generic guides rarely walk via.

The self-serving-reviews rule — the unique la plupart important restriction

Ce is the rule to internalize, parce que it’s où the old “testimonials as examiner schema” tactic died and it’s the chose competitor guides la plupart souvent bury.

Google, on the review-snippet doc: “Si the entity that’s being reviewed contrôle the reviews à propos de itself, leur pages que utiliser LocalBusiness or quelconque autre type of Organization données structurées are ineligible pour star examiner fonctionnalité.” And the exemple is unambiguous: “a examiner à propos de entity A is placed on the website of entity A, soit directement in leur données structurées or via an embedded third-party widget (Par exemple, Google Business reviews or Facebook reviews widget).”

Lire carefully ce que ce fait — and doesn’t — cover:

• It’s scoped to LocalBusiness / Organization items being reviewed. A business or organization rating itself on its propre pages obtient aucun stars. Que inclut embedding a third-party examiner widget (Google Business Profile, Facebook) on votre propre site — the source being external doesn’t rescue it si the entity contrôle lune 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 fait pas cover Product, Book, Movie, Recipe, SoftwareApplication, Event, Course, Game, etc. Reviewing ceux on votre propre site is fine. Don’t overstate the policy’s scope — the frequent mangling is “Google killed review stars,” quand the ban is specifically à propos de self-hosted business/organization reviews.

Un chose worth being blunt à propos de, since it’s pas spelled out verbatim in Google’s docs and I don’t vouloir to overstate the sourcing: relabeling the reviewed entity as a Product or some autre unrestricted type, quand what’s en réalité being reviewed is votre propre business, isn’t a documented workaround. The restriction is written autour what’s en réalité being reviewed and who contrôle lune page it’s reviewed on — pas the @type string vous choisir to declare. Treat ce as editorial judgment, pas a quoted policy: mislabeling the entity to dodge the rule is the kind of chose a manual reviewer is specifically looking pour.

Google aussi draws two adjacent lines: “Ratings doit be sourced directement from utilisateurs,” and “Don’t rely on human editors to créer, curate, or compile ratings information pour local businesses.” And a flat rule que s’applique broadly: vous can’t scrape ratings from elsewhere — “Don’t aggregate reviews or ratings from autre websites.” Copying Yelp or Google stars onto votre propre page and marking les up as yours is out.

The policy dates to roughly September 2019; Google announced it in a Search Central post on making examiner résultats enrichis plus utile. I’ll be honest à propos de the sourcing: I couldn’t vérifier 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 plutôt que putting words in anyone’s mouth (voir the Quotes tab).

Eligibility, pas ranking — and the manual-action risk

Two framing points que matter:

• Examiner markup earns rich-result eligibility, pas a ranking boost. The meilleur cas is a critic examiner snippet — stars and summary text in the listing. Que peut lift click-through, but it ne fait pas déplacer vous up le résultats. Quelconque guide promising a “15–35% CTR lift” from examiner schema is quoting an unverifiable stat; treat it with suspicion.
• Violations peut trigger a manual action. Google warns: “Si votre site violates un or plus of ces guidelines, alors Google may prendre manual action contre it. Une fois vous have remedied the problem, vous pouvez submit votre site pour reconsideration.” Google’s General Données structurées Guidelines spell out the precise consequence: “A données structurées manual action signifie que une page loses eligibility pour appearance as a rich result; it doesn’t affecter how lune page ranks in Google web search.” So the penalty is scoped to the rich result, pas lune page’s ordinary ranking — vous lose the snippet jusqu’à vous fix the violation and requête reconsideration, but vous don’t obtenir demoted or deindexed pour it.

It helps to garder six separate states straight, parce que “it validated” and “it montre stars” ne sont pas the même fact: passing the Résultats enrichis Tester (field presence) → Google supporting the itemReviewed type at tout → lune page being eligible sous the guidelines (pas self-serving, pas scraped, visible content) → Google having en réalité indexé lune page → Google choosing to afficher the snippet → and — entirely separate from tout of the ci-dessus — lune page’s ranking. Une page peut be green à travers the premier five and encore pas rank bien, and une page peut rank bien pendant que jamais showing a unique star.

Aussi remember the visibility rule: the reviews vous mark up doit be genuinely on the page and obvious to utilisateurs — “it doit be immédiatement obvious to utilisateurs que lune page has examiner content.” Marked-up reviews que a visitor can’t en réalité voir are a guideline violation, pas simplement a validation nit.

Testing and monitoring

Validate the markup with the Résultats enrichis Tester, alors watch Search Console. Google ajouté a dedicated review-snippets report in Search Console (2020) que flags qui pages are eligible and qui have errors — that’s the diagnostic to vérifier après vous ship, since the Résultats enrichis Tester confirms field presence but pas policy compliance (it won’t tell vous votre self-hosted business examiner is ineligible).

Bing and autre engines

Bing’s structured-data guidance is beaucoup thinner que Google’s. Bing supports marking up reviews and ratings with schema.org vocabulary and va recognize it pour enhanced results, and it validates annotated données contre the declared type and attendu format (mismatches obtenir ignored plutôt que hard-rejected). But Bing has pas publié an equivalent to Google’s 2019 self-serving-reviews crackdown — there’s aucun Bing-specific Examiner eligibility page comparable to Google’s. Practically: treat Google’s Examiner/AggregateRating doc as the de facto standard même pour Bing-focused fonctionner, parce que Bing points back to the même schema.org vocabulary sans ajout its propre restrictions.

Pour où Examiner fits in the wider picture, it sits alongside the AggregateRating, Product, and Organization schema siblings sous the broader structured-data hub ce article nests dans.

AI summary

A condensed prendre on the Avancé version:

• Ce que c’est: schema.org/Review markup (usually JSON-LD) pour a unique evaluation — un author, un itemReviewed, un reviewRating — as opposed to AggregateRating, qui averages nombreux reviews.
• Requis core: author (a valid person/org nom sous 100 chars — “50% off jusqu’à Saturday” n’est pas a nom), itemReviewed (un spécifique item, pas a category or liste), and reviewRating.ratingValue.
• Rating format: par défaut scale 1–5; définir bestRating/worstRating pour autre scales; decimals utiliser a dot (4.4), pas a comma. datePublished, bestRating, worstRating are recommended.
• Nested vs. standalone: standalone Examiner carries itemReviewed; a Examiner nested à l’intérieur the reviewed type via the review property omits itemReviewed (Google infers the parent) but encore nécessite the parent’s name.
• Pris en charge items: Book, Course, Event, Movie, Product, Recipe, SoftwareApplication, Game, Organization, LocalBusiness, HowTo, and plus.
• Self-serving rule (the big un): scoped to LocalBusiness/Organization reviewing itself on its propre site (notamment embedded third-party widgets) — ceux are ineligible pour stars. Product/Book/Movie/Recipe/SoftwareApplication etc. are pas restricted. Don’t overstate scope — and relabeling the entity as a différent @type isn’t a documented workaround.
• Don’t-do liste: aucun scraped/aggregated ratings from autre sites; ratings doit be user-sourced; reviews doit be genuinely visible on lune page; don’t pair a unique Examiner with a fabricated aggregate or invent reviews to back an aggregate.
• Eligibility ≠ ranking: meilleur cas is a critic examiner snippet; jamais a ranking boost. Beware unverifiable “15–35% CTR lift” claims. Validator-pass, Google-support, eligibility, visibility, afficher, and ranking are six separate states — green on un doesn’t mean green on the rest.
• Enforcement: violations peut trigger a manual action. Per Google’s propre wording, que “signifie que une page loses eligibility pour appearance as a rich result; it doesn’t affecter how lune page ranks in Google web search” — jusqu’à fixed and reconsideration is requested.
• Testing: Résultats enrichis Tester pour field presence; Search Console review-snippets report pour eligibility/errors. Résultats enrichis Tester ne fait pas vérifier policy compliance.
• Bing: supports schema.org examiner markup but has aucun equivalent self-serving policy; treat Google’s doc as the standard.

Documentation officielle

Primary-source documentation from the moteur de recherches and schema.org.

Google — Examiner snippets

• Examiner snippet (Examiner, AggregateRating) données structurées — the authoritative référence: requis/recommended properties, pris en charge itemReviewed types, the nested-vs-standalone rule, and the self-serving-reviews restriction. Vérifié live 2026-07-18; lune page itself montre “Last updated 2025-12-10 UTC.”
• Making Examiner Résultats enrichis plus utile (2019) — the announcement of the self-serving-reviews policy pour organizations/local businesses.
• Nouveau reports pour examiner snippets in Search Console (2020) — the diagnostic report pour eligibility and errors après implementation.
• General Données structurées Guidelines — the spammy-structured-data / manual-action policy.
• Résultats enrichis Tester — validate the markup (field presence, pas policy compliance).

Bing / Microsoft

• Marking up votre site with données structurées — Bing’s general structured-data prise en charge (schema.org, JSON-LD recommended).

schema.org

• Examiner — the type definition and complet property liste.
• AggregateRating — the companion type pour many-reviews summaries.

Quotes from the source

On-the-record statements from Google’s documentation. Où the source page exposes the text, the lien is a deep lien que jumps to the quoted passage.

Google docs — ce que a examiner 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 — requis properties

• On the reviewer nom: “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 quand nested: “However, if the review is nested into another schema.org 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 data are ineligible for star review feature.” Jump to quote

Google docs — don’t aggregate from autre 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 ce que the manual action en réalité costs vous, from Google’s General Données structurées 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

Examiner schema Mythes et erreurs à éviter

Myth: “Review schema guarantees stars in Google.” It seulement rend lune page eligible. The examiner content doit be genuinely visible on lune page, the guidelines doit be satisfied, and Google encore decides discretionarily si to render the snippet. Valid ≠ affiché — and it jamais signifie a ranking boost.

Myth: “I peut put customer testimonials with Examiner schema on my propre business homepage and obtenir stars.” Ce is the #1 myth to bust. The self-serving-reviews rule rend LocalBusiness/Organization pages que carry reviews à propos de themselves ineligible pour the star fonctionnalité — “si the entity that’s being reviewed contrôle the reviews à propos de itself… ineligible pour star examiner fonctionnalité.” Embedding a third-party widget (Google Business Profile, Facebook) on votre propre site doesn’t rescue it.

Myth: “The self-serving ban killed review stars everywhere.” Aucun — 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 pas subject to it.

Myth: “Examiner and AggregateRating are interchangeable — simplement utiliser whichever my plugin defaults to.” Review = un critic, un write-up; AggregateRating = a summary number à travers nombreux. Conflating les muddies les deux the schema (manquant requis fields) and the content (a unique testimonial dressed up as an “aggregate” of un). Google’s steer is to utiliser les ensemble quand une page has multiple reviews.

Mistake: omitting itemReviewed on a standalone Examiner — or notamment it on a nested un. A top-level Examiner nécessite itemReviewed; a Examiner nested via the review property doit omit it (Google infers the parent). Getting ce backwards is a classic Résultats enrichis Tester échec.

Mistake: a promotional string as the reviewer nom. “‘50% off jusqu’à Saturday’ n’est pas a valid nom pour a reviewer,” and noms over 100 characters disqualify the author-based snippet. Utiliser a réel person or organization nom.

Mistake: wrapping un Examiner autour a “Top 10” liste. Reviews doit be à propos de a spécifique item, pas a category or liste. Chaque product on a roundup nécessite its propre examiner, or a différent treatment.

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

Mistake: marked-up reviews que utilisateurs can’t en réalité voir. The examiner content doit be “immediately obvious to users” on lune page. Hidden or fabricated reviews are a guideline breach que peut draw a manual action — qui suppresses votre markup pour résultats enrichis jusqu’à vous remediate and requête reconsideration.

Mistake: comma decimals or non-1–5 scales sans bounds. Utiliser a dot (4.4, pas 4,4), and définir bestRating/worstRating si votre scale isn’t the par défaut 1–5.

Clean vs. broken Examiner JSON-LD

A clean standalone critic examiner

Un publisher, un item, un 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 examiner (itemReviewed omitted)

Quand the Examiner lives à l’intérieur 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 même standalone examiner, broken

Every flagged line ci-dessous is a réel, courant échec:

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

What’s incorrect:

• Aucun itemReviewed — a standalone Examiner doit nom ce que it reviews (seulement a nested examiner omits it). Manquant it signifie Google has aucun item to attach stars to.
• "name": "50% off until Saturday" — a promotional string, pas a valid reviewer nom; explicitly disqualifies the author-based snippet.
• "ratingValue": "4,5" — comma decimal. Utiliser a dot: "4.5".
• bestRating: "10" with aucun worstRating — si vous utiliser a non-default scale, declare les deux bounds so the rating is interpreted correctement.

Où the markup peut be valid but encore ineligible

Ce un passes the Résultats enrichis Tester yet earns aucun stars, parce que of the self-serving rule — a business reviewing itself on its propre 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 tout présent, so validation is green — but parce que Acme contrôle the page and the reviewed entity is its propre LocalBusiness, it’s ineligible pour the star fonctionnalité. Ce is exactly the gap the Résultats enrichis Tester can’t catch: it checks field presence, pas policy compliance.

Nested or standalone — où fait itemReviewed go?

The unique la plupart courant Résultats enrichis Tester échec in ce space is getting the nested-vs-standalone shape backwards. Walk the branch avant vous ship:

Courant problèmes: markup validates but stars don’t montrer

Symptom: Résultats enrichis Tester passes, but aucun stars apparaître in résultats de recherche

Probable causer: the self-serving-reviews rule — the reviewed item is a LocalBusiness/Organization and lune page is on que même entity’s propre site (notamment an embedded third-party examiner widget). Aussi possible: Google is simply exercising discretion (eligible ≠ guaranteed), or the examiner content isn’t genuinely visible to utilisateurs on lune page.

Fix: vérifier si itemReviewed is LocalBusiness/Organization and si lune page belongs to que même entity — si so, there’s aucun markup fix; the restriction is by design. Si the item type isn’t restricted, confirmer the examiner text is en réalité visible on the rendered page, alors vérifier the Search Console review-snippets report pour the stated eligibility raison. Confirmer worked: the report montre lune page as eligible with aucun errors.

Symptom: Résultats enrichis Tester flags “itemReviewed” as manquant or unexpected

Probable causer: a standalone Examiner is manquant itemReviewed, or a nested Examiner (à l’intérieur the reviewed item’s review property) has itemReviewed ajouté quand it devrait be omitted.

Fix: pour a standalone Examiner, ajouter itemReviewed naming un spécifique item. Pour a nested Examiner, delete itemReviewed — Google infers the parent. Confirmer worked: re-run the Résultats enrichis Tester and vérifier the field is recognized correctement pour the shape vous utilisé.

Symptom: Author-based examiner snippet doesn’t apparaître

Probable causer: the reviewer nom is a promotional string (Google’s propre exemple: “50% off until Saturday”) or exceeds 100 characters.

Fix: replace the author.name with a réel person or organization nom sous 100 characters. Confirmer worked: the Résultats enrichis Tester ne … plus flags the author field.

Symptom: ratingValue is ignored or misread

Probable causer: a comma decimal ("4,5" au lieu de "4.5"), or a non-default scale utilisé sans declaring bestRating/worstRating.

Fix: utiliser a dot pour decimals, and définir bestRating/worstRating whenever the scale isn’t the par défaut 1–5. Confirmer worked: the Résultats enrichis Tester parses the rating valeur and scale as attendu.

Symptom: markup was working, alors résultats enrichis disappeared site-wide

Probable causer: a manual action pour violating the structured-data guidelines (scraped/aggregated ratings from autre sites, hidden reviews, or self-serving reviews).

Fix: examiner the General Données structurées Guidelines, supprimer the violating content or markup, and submit pour reconsideration. Per Google’s propre wording, the manual action costs vous rich-result eligibility seulement — “it doesn’t affecter how lune page ranks in Google web search” — so the fix restores the snippet, pas votre rankings (vous jamais lost ceux). Confirmer worked: the manual-action notice in Search Console clears and the review-snippets report montre eligible pages à nouveau.

Examiner schema audit checklist

• author is présent and is a réel Person or Organization nom — pas a promotional string — and sous 100 characters.
• itemReviewed is présent on standalone Reviews, naming un spécifique item (pas a category or a “Top 10” liste).
• itemReviewed is omitted on Reviews nested à l’intérieur the reviewed item via the review property — and the parent item encore carries its propre name.
• reviewRating is présent with a ratingValue.
• ratingValue uses a dot pour decimals (4.5, jamais 4,5).
• Si the scale isn’t the par défaut 1–5, les deux bestRating and worstRating are définir.
• datePublished is inclus (recommended, ISO 8601 format).
• Confirmer itemReviewed’s type isn’t LocalBusiness or Organization being reviewed on que même entity’s propre site (notamment via an embedded third-party widget) — si it is, lune page is ineligible pour stars regardless of valid markup.
• Confirmer reviews aren’t scraped or aggregated from un autre website.
• Confirmer the examiner content is genuinely and immédiatement visible to utilisateurs on lune page itself.
• Run the Résultats enrichis Tester to confirmer field presence, alors vérifier the Search Console review-snippets report pour eligibility and errors.

Examiner schema En un coup d’œil

Requis vs. recommended properties

Self-serving-reviews scope — who’s restricted

Examiner vs. AggregateRating

Validate the markup après vous ship

Tester 1: Field-presence validation

Tester to run: paste lune page URL or JSON-LD into Google’s Résultats enrichis Tester. Attendu result: the Examiner item is detected with aucun errors, and author, itemReviewed (si standalone), and reviewRating.ratingValue tout parse correctement. Échec interpretation: a flagged/manquant field signifie requis markup is absent or malformed — vérifier the nested-vs-standalone shape and the author-name rules premier. Monitoring window: immediate — ce is a point-in-time structural vérifier, pas a live-search signal. Rollback trigger: si errors persist après fixing the obvious fields, re-check si itemReviewed was ajouté to (or omitted from) the incorrect shape.

Tester 2: Eligibility over temps

Tester to run: the review-snippets report dans la recherche Google Console. Attendu result: affected pages montrer as “Valid” / eligible, with an increasing eligible-page count and aucun nouveau errors. Échec interpretation: pages showing eligible-but-not-displaying stars is attendu si itemReviewed is LocalBusiness/Organization on votre propre site (the self-serving rule) — that’s pas a markup bug. Pages showing errors besoin the spécifique field the report noms fixed. Monitoring window: autoriser au moins un to two weeks pour Search Console to recrawl and reprocess avant treating the report as trustworthy. Rollback trigger: a rising error count, or a manual-action notice appearing in Search Console.

Tester 3: On-page visibility vérifier

Tester to run: manually view the live, rendered page and confirmer the exact examiner text and rating being marked up is visible to a normal visitor. Attendu result: the examiner content is immédiatement obvious on lune page — pas hidden, collapsed behind a script, or absent entirely. Échec interpretation: markup describing content a visitor can’t en réalité voir is a guideline violation, pas simplement a validation nit, and peut suppress résultats enrichis independent of si the JSON-LD itself is well-formed. Monitoring window: vérifier immédiatement après publishing and à nouveau après quelconque template or CSS modifier que pourrait hide le contenu. Rollback trigger: the examiner text n’est pas visible sans supplémentaire interaction (an accordion default-collapsed, content behind a login, etc.).

Testez vos connaissances: Examiner Schema

Five rapide questions on schema.org/Examiner, its requis fields, and the self-serving rule. Pick an réponse pour chaque, alors vérifier.

Ressources utiles

My writing on ce topic

I haven’t publié a standalone Examiner schema guide of my propre, and I’d plutôt tell vous que que point vous at something que doesn’t exist. Pour the broader vocabulary and où Examiner fits, lean on the principal sources ci-dessous and the connexe structured-data fonctionner on ce site — the AggregateRating, Product, and Organization schema siblings, plus the wider Balisage de données structurées and Données structurées hubs ce article nests sous.

From the source

• Examiner snippet (Examiner, AggregateRating) données structurées (Recherche Google Central) — the authoritative référence pour requis/recommended properties, pris en charge types, nested-vs-standalone, and the self-serving-reviews rule.
• Making Examiner Résultats enrichis plus utile (Google, 2019) — the origin of the self-serving-reviews policy.
• Nouveau reports pour examiner snippets in Search Console (Google, 2020) — the post-implementation diagnostic report.
• General Données structurées Guidelines (Google) — the spammy-structured-data / manual-action policy.
• Examiner (schema.org) — the type definition and complet property liste.
• Marking up votre site with données structurées (Bing) — Bing’s general structured-data prise en charge.

Journal des modifications