Review Schema Markup: When Stars Show (and When They Don't)

Review schema markup is the JSON-LD that describes a Review or an AggregateRating so crawlers and AI assistants can read it directly instead of parsing star icons on a page. Google only turns that markup into a visible star rich snippet under specific conditions tied to who controls the reviews, and most local businesses marking up their own page will not meet them. Review schema markup exists to describe reviews accurately for machines, not to win your own business a row of stars in someone else’s search results, and for most local businesses marking up their own page, Google will not show those stars at all. This guide walks through exactly when stars can appear, the rule that blocks them for most local businesses, valid Review and AggregateRating examples with placeholder values, where the numbers in that markup have to come from, how to actually show reviews on your site, and how to validate the result.

How review schema markup works, and when stars can appear

Per Google’s structured data documentation for the review snippet, “when Google finds valid reviews or ratings markup, we may show a rich snippet that includes stars and other summary info from reviews or ratings.” That snippet can surface across several content types, including books, courses, recipes, software apps, local businesses and products, in regular search results or in a Knowledge Panel.

Two words there do a lot of work: “may show.” Valid markup is a precondition, not a guarantee. Google reserves the right to withhold the rich result for any page, and it applies one rule specifically that rules out the case most small businesses actually want: marking up reviews of themselves.

The self-serving reviews rule (why your own LocalBusiness page won’t get stars)

Google states it plainly: “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.” The same guidance clarifies the mechanism it is closing: “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).”

Unpack that carefully, because it answers three questions at once:

• It doesn’t matter how the reviews got onto your page. Hand-typed JSON-LD and an embedded Google or Facebook reviews widget are treated the same way for eligibility.
• It applies to LocalBusiness and Organization (and their subtypes, such as Dentist or Plumber), not to every schema type. The rule specifically calls out an entity reviewing itself. A Product reviewed by an independent third party, for example an editorial review site covering a product it did not make, remains eligible for the star snippet. A dental practice’s own site marking up reviews of the dental practice is not, because the practice controls both the page and the reviews on it.
• Valid markup does not override the rule. Perfectly formed AggregateRating schema on your LocalBusiness page will not produce stars in web search results, because the ineligibility is about who controls the entity, not about the correctness of the code.

If your business already shows a star rating and review count in Google Search or Maps, that is your Google Business Profile doing its own separate job, a system Google manages directly from data it collects on its own platform. It is not something your on-page schema produces, and it is not something a citation or SEO tool posts, edits or syncs on your behalf; see reviews and local SEO for how that separate signal actually works and what moves it.

Required and recommended properties

Property	Type	Status	Notes
author	Review	Required	A Person or Organization object
reviewRating.ratingValue	Review	Required	Nested inside a Rating or AggregateRating object
itemReviewed	Review	Required (if not nested)	Omit if the Review sits inside the entity it reviews
datePublished	Review	Recommended	ISO date the review was published
reviewRating.bestRating / worstRating	Review	Recommended	Defines the scale, defaults to 5 and 1 if omitted
ratingValue	AggregateRating	Required	The average score
ratingCount or reviewCount	AggregateRating	Required (at least one)	How many ratings the average is built from
itemReviewed.name	AggregateRating	Required (if not nested)	The name of the thing being rated
bestRating / worstRating	AggregateRating	Recommended	Same scale rules as above

Valid JSON-LD examples (placeholder values only)

Two shapes cover almost everything a local business will encounter. Replace every placeholder with values that genuinely appear on the page; neither example below describes a real business.

AggregateRating nested in a LocalBusiness block. This is what most local businesses will actually add, with the eligibility limits above understood going in:

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Your Business Name",
  "url": "https://www.example.com",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "132",
    "bestRating": "5",
    "worstRating": "1"
  }
}

A single Review, nested in the entity it describes. Used when an individual review, with its own author and date, is shown as visible text on the page:

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Your Business Name",
  "review": {
    "@type": "Review",
    "author": {
      "@type": "Person",
      "name": "Reviewer Name"
    },
    "datePublished": "2026-03-14",
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": "5",
      "bestRating": "5",
      "worstRating": "1"
    },
    "reviewBody": "Replace this with the exact review text as it is displayed on the page."
  }
}

Both examples are structurally correct Review and AggregateRating markup. Neither will produce a star rich snippet on a LocalBusiness page you control, for the reason covered above. What they do is give any system parsing your page, search engine or AI assistant, an unambiguous, correctly typed summary of your reputation instead of forcing it to guess from icons and stray numbers in the page text.

Where the numbers must come from

This is the part that gets small businesses into trouble, and it is worth stating as a rule rather than a suggestion: every value in Review or AggregateRating markup must come from reviews that are readily visible to a human visitor on that same page. Google’s guidance is direct about it: “Make sure the review content you mark up are readily available to users from the marked-up page. It must be immediately obvious to users that the page has review content.” The same documentation warns against fake or undisclosed incentivized reviews in either the page content or the structured data.

In practice that means:

1. Never copy a rating from a platform you don’t display. If your aggregateRating says 4.8 from 132 reviews, a visitor should be able to see something close to 132 reviews, or a clear summary of them, on that page. A number lifted from your Google Business Profile with nothing matching on the page is exactly the mismatch the policy targets.
2. Update the markup when the visible reviews change. A static reviewCount next to a review list that has grown or shrunk since the schema was written is a small, easy-to-miss inconsistency, and one worth checking after any redesign or plugin update, the same way you would recheck LocalBusiness schema after a site change.
3. Never mark up reviews the page doesn’t disclose as incentivized. If a review was collected in exchange for a discount, a gift or payment, either don’t mark it up or disclose the incentive per the platform’s own rules; that disclosure obligation exists independent of schema, and it’s the same line covered in fake Google reviews on the display side and the review gating glossary entry on the collection side.

The underlying quantity, quality, recency and spread of the reviews behind these numbers, what our guide to reviews and local SEO calls review signals, is a real local ranking input. Schema just describes that input; it doesn’t create it.

How to show reviews on your site, and how that interacts with schema

There are two separate decisions here, and they’re often conflated: how you display reviews to human visitors, and how you describe that same content to machines. Get the display right first, because the schema has to describe what’s actually on the page, not the other way round.

• A native list of reviews you wrote or collected. Text, author name, date and star rating rendered directly in your page’s HTML. This is the simplest case to keep schema in sync with, because the visible content and the markup are maintained in the same place. Include the occasional critical review with your reply rather than only five-star quotes; see how to respond to negative reviews for the approach, and keep the schema’s reviewRating values honest either way.
• An embedded third-party widget (a Google reviews widget, a Facebook reviews plugin, a review-platform embed). Visually this can look identical to a native list, but remember the self-serving rule applies to these too: an embedded widget showing reviews of your own LocalBusiness, on your own LocalBusiness page, does not become eligible for the star snippet just because the reviews technically live on a third-party platform. Google’s own examples explicitly name Google Business and Facebook reviews widgets as covered by the rule.
• A dedicated testimonials or case-studies page, separate from your main service pages. Useful for display, but the same visibility rule applies wherever you add Review or AggregateRating markup: the numbers must match what’s shown on that specific page.

Whichever you choose, keep one thing constant: the schema block should sit on the same page as the reviews it describes, using the exact figures visible there, updated when the display updates.

Validating what you built

Two separate checks, and they answer different questions:

1. Is the markup valid JSON-LD, using real Review and AggregateRating properties correctly? Run the page through the tools in how to validate LocalBusiness schema. A general-purpose validator will confirm the structure regardless of Google’s eligibility rules.
2. Does the review content on the page actually match the schema, and does your overall LocalBusiness block agree with the rest of your citations? That’s a truthfulness check a validator can’t run for you. Our complete guide to LocalBusiness schema markup and the short LocalBusiness schema glossary entry cover how the whole block, reviews included, should sit alongside your Google profile and directory listings, not just how to make it parse.

The takeaway

Review schema is a description, not a marketing lever. Write it to match what a visitor genuinely sees on the page, understand that your own LocalBusiness reviews will not earn stars in Google’s results no matter how clean the JSON-LD is, and treat the actual work of earning reviews (covered in reviews and local SEO) as the separate job it is. If you want customers to leave the reviews this markup will eventually describe, our Google review link generator creates a direct link straight to your review form, no schema required to use it. For the rest of your local SEO foundation, the local SEO hub covers where structured data fits alongside citations, your Google profile and the fundamentals that actually move rankings.