How to Get Star Ratings in Google Search Results

Those gold star ratings in Google's results are one of the most valuable rich results you can earn: they make your listing stand out, signal trust at a glance, and can meaningfully lift your click-through rate. The good news is they're genuinely achievable. The catch is that star ratings come with specific rules that most guides get wrong, and getting them wrong doesn't just mean no stars, it can mean a manual action that gets your markup ignored entirely.

So this guide does two things: shows you exactly how to earn star ratings the right way, and keeps you clear of the traps that cost people their stars (or worse). We'll cover which content types can actually show stars, the "self-serving reviews" rule that disqualifies most local businesses who try the obvious approach, a brand-new July 2026 rule on incentivized reviews you need to know about, and how to keep your stars from vanishing once you've earned them. Let's get you those stars, properly.

What star ratings are, and why they're worth earning

Star ratings appear in what Google calls the review snippet, the row of gold stars, often with an average score and review count, shown beneath a search result. They're powered by structured data (Review and AggregateRating markup) that tells Google a rating lives on your page.

They're worth earning because they do something few rich results do: they add instant visual trust. In a list of similar results, the one with four-and-a-half stars and a healthy review count draws the eye and the click. For products, recipes, courses, and software especially, that social proof right in the results can be the difference between your listing and a competitor's.

But, and this is the whole point of doing it right, star ratings are a privilege Google extends when your structured data passes its rules and matches what visitors actually see. Google rechecks eligibility on every crawl, so stars can appear, and they can vanish. Earning them and keeping them both come down to following the rules below.

Review vs AggregateRating: the two you'll use

Two markup types do this job, and people constantly mix them up:

Review describes a single individual rating, one person's score and usually their written opinion, with an author.

AggregateRating summarizes many reviews into one average: a ratingValue (the average score) and a reviewCount or ratingCount (how many). This is what most businesses showing multiple reviews use, because it's the summary that produces the familiar "4.6 stars, 213 reviews" display.

Most of the time you'll want AggregateRating for the summary star display. Use Review when you're marking up specific individual reviews. They can appear together, an aggregate score plus individual reviews, but the aggregate is what typically drives the star snippet.

The rule everyone gets wrong: self-serving reviews

Here's the single most important thing in this guide, and it's the rule most "how to get star ratings" articles either miss or get dangerously wrong. Get this right and you'll succeed where most fail.

A business cannot show star ratings for reviews about itself, hosted on its own website, using LocalBusiness or Organization schema. This is Google's "self-serving review" rule, and it's explicit in their documentation: if the entity being reviewed controls the reviews about itself, its pages using LocalBusiness or any type of Organization structured data are ineligible for the star review feature.

In plain terms: if you run a local business and you put reviews about your own business on your own site and mark them up with AggregateRating on your LocalBusiness schema, you will not get stars, and attempting it can flag your site. This includes reviews you've collected yourself and reviews pulled in through an embedded third-party widget (like a Google Business reviews or Facebook reviews widget) placed on your own page. Google considers all of that self-serving.

This matters enormously because the "obvious" approach, adding AggregateRating to your LocalBusiness schema so your homepage shows stars, is exactly the thing that doesn't work and can hurt you. Plenty of guides still recommend it. Don't do it. The reviews that earn stars for a business must come from independent third-party sources, not from the business reviewing itself.

Google also states plainly: ratings must be sourced directly from users, and you shouldn't rely on human editors to create, curate, or compile ratings for local businesses. The stars are meant to reflect genuine, independent customer sentiment, not a score a business assigns itself.

So if you're a local business, hold that thought, there's a legitimate path to stars for you, covered below. But first, the types that can show stars on your own site, because for many businesses this is the straightforward win.

Which content types CAN show stars on your own site

Here's the encouraging flip side: a specific set of content types are exempt from the self-serving restriction and can carry Review and AggregateRating markup on your own site, showing stars for genuine reviews. As of 2026, the eligible types include:

• Product, the big one for ecommerce. Product pages can show star ratings for genuine customer reviews of that product.
• Recipe, recipe pages can show ratings from people who made the recipe.
• Book, book pages and reviews.
• Course, course pages can show learner ratings.
• SoftwareApplication, software and app pages can show user ratings.
• Movie and other creative works, reviews of films, media, and creative content.
• Several other specific item types.

The distinction is the key insight: these are reviews of a specific item (a product, a recipe, a course), not a business reviewing itself. An online store showing genuine customer ratings on a product page is marking up reviews of the product, which is allowed and works well. That's why ecommerce, recipe, course, and software sites can and should use review markup on their own pages, while a local service business cannot do the equivalent for itself.

So the first question to ask is: what's actually being reviewed? If it's a product, recipe, course, book, software, or creative work, you can show stars on your own site (with genuine reviews). If it's your business reviewing itself, you can't, and you need the third-party path next.

How local businesses legitimately get stars

If you're a local or service business, you're not shut out, you just take a different, legitimate route, and it's worth understanding clearly.

Stars come from independent third-party platforms. Review platforms like Trustpilot, Yelp, and industry-specific aggregators can mark up reviews about your business, because they're an independent party collecting the reviews, not you reviewing yourself. That's not self-serving, so it's eligible. This is why you'll often see star ratings for businesses appearing via these third-party platforms in search results.

So the legitimate local-business strategy isn't to mark up your own reviews, it's to build a genuine, strong presence on the independent review platforms that matter in your industry, and let their eligible markup do the work. That's also good for your business regardless of schema: real reviews on trusted platforms build reputation, feed your Google Business Profile, and increasingly feed AI systems that recommend local businesses. We cover the local-visibility side of this in our multi-location and local business guide.

The honest takeaway for local businesses: focus your energy on earning genuine reviews on independent platforms and keeping your Google Business Profile strong, not on trying to force stars onto your own site, which won't work and can backfire.

A complete example: Product with AggregateRating

Here's correct markup for an eligible type, a product page showing an aggregate star rating from genuine reviews:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Single-Origin Ethiopian Coffee Beans",
  "image": "https://example.com/products/ethiopian-beans.jpg",
  "description": "Whole-bean single-origin Ethiopian coffee, medium roast.",
  "brand": {
    "@type": "Brand",
    "name": "Bright Coffee Roasters"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "213"
  },
  "offers": {
    "@type": "Offer",
    "price": "18.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

The key elements: it's on an eligible type (Product), the aggregateRating has a ratingValue and a reviewCount, and, critically, those numbers must match reviews genuinely visible on the page. That last point is the one that trips people up most, so let's cover it.

The rule that decides everything: markup must match the page

Google requires that the ratings and reviews in your markup be present and visible on the page itself. If your markup claims a rating and a count, a visitor must be able to see that rating and those reviews on the page.

This is the single most common reason star ratings fail or vanish. If your AggregateRating says 213 reviews but the page visibly shows 38, or shows a review widget that failed to load, or renders the reviews only via JavaScript the crawler didn't execute, the markup no longer matches what's visible, and the snippet becomes ineligible. Google is strict about this: the structured data and the visible content have to agree.

This breaks most often after a redesign, a migration, or a plugin update: the markup gets left behind in the theme while the visible reviews moved, changed, or stopped rendering. The two silently fall out of sync, and the stars quietly disappear. Keeping your markup and your visible reviews in agreement is the ongoing discipline that keeps your stars.

New for 2026: no fake or undisclosed incentivized reviews

Here's a recent change you need to know about, because it's very new and carries real consequences. On July 24, 2026, Google updated its review snippet documentation to explicitly prohibit fake reviews and undisclosed incentivized reviews, in both your page content and your structured data.

Specifically, Google now names two things you must not include:

• Reviews not based on a genuine product or service experience, fabricated or fake reviews.
• Reviews written in exchange for money, discounts, vouchers, free products, or similar benefits, when that incentive is not clearly and prominently disclosed.

The consequence is serious: violating this can trigger a manual action, which causes the structured data on the affected page to be ignored, your page stays in search results, but your stars (and other markup benefits) are gone. This aligns with broader regulatory moves against fake and undisclosed paid reviews, so it's part of a wider tightening, not a one-off.

The practical guidance is simple and worth following carefully: only mark up genuine reviews from real experiences, and if any reviews were incentivized in any way, a discount, a free product, a voucher in exchange for the review, that incentive must be clearly and prominently disclosed on the page. Authentic, transparent reviews are the only safe foundation for star ratings now. This is a good rule for trust anyway, and now it's an eligibility requirement.

Why star ratings vanish (and how to diagnose it)

Because eligibility is rechecked on every crawl, stars that showed for months can disappear. Here are the causes, most common first, so you can diagnose quickly:

1. Your markup no longer matches the visible reviews. The most common cause by far. The rating or count in your structured data disagrees with what's on the page, often after a redesign or migration left the markup behind. Fix: make the two agree, then revalidate.

2. The reviews are self-serving. You're a business reviewing itself on your own site with LocalBusiness/Organization markup, ineligible, as covered above. Fix: move to eligible item types or third-party platforms.

3. A manual action or policy change. A violation (like the new incentivized-review rule) or a policy update pulled your eligibility. Fix: check Search Console for manual actions, resolve the violation, request reconsideration.

4. Reviews render only in JavaScript the crawler skipped. If your review content only appears after client-side JavaScript runs, the crawler may not see it, so the markup has nothing visible to match. Fix: ensure reviews are in the server-rendered HTML.

5. The rating count no longer agrees with the page. A dynamic count that's drifted out of sync with the markup. Fix: keep them synchronized.

The diagnostic tool for all of these is Google's Rich Results Test: open the live URL, read the parsed AggregateRating, and compare it against what a visitor sees. Most "my stars disappeared" mysteries resolve there before you ever need to assume a penalty.

Your requirements checklist

To earn and keep star ratings:

• Use an eligible item type, Product, Recipe, Book, Course, SoftwareApplication, Movie, or another eligible type, not LocalBusiness/Organization reviewing itself.
• Include the required properties, ratingValue and reviewCount or ratingCount in your AggregateRating.
• Make reviews genuinely visible on the page, matching your markup exactly.
• Serve reviews in the rendered HTML, not only via client-side JavaScript.
• Use only authentic reviews, no fake reviews, and disclose any incentivized ones clearly and prominently.
• Keep markup and visible content in sync as your reviews change.
• Validate and monitor with the Rich Results Test and Search Console.

Common mistakes to avoid

Adding AggregateRating to your own LocalBusiness schema. The classic mistake, it's self-serving and ineligible, and can flag your site. Use eligible item types or third-party platforms.

Marking up more reviews than are visible. A count in your markup that exceeds what's on the page breaks eligibility. Match exactly.

Embedding a reviews widget and marking it up as your own. Third-party widgets showing reviews about you, placed on your own site, are still self-serving.

Undisclosed incentivized reviews. Now explicitly prohibited and manual-action-worthy. Disclose incentives clearly, or don't mark up those reviews.

Reviews only in JavaScript. The crawler may not see them, so there's nothing visible to match. Server-render them.

Set-and-forget markup. Reviews change; static markup drifts out of sync and the stars vanish. Keep them aligned.

Implementing it on WordPress

Your approach depends on what's being reviewed and how your reviews are managed.

For eligible types, products, recipes, courses, software, you want AggregateRating markup on those item pages that accurately reflects the genuine reviews visible on the page, and stays accurate as reviews come in. The recurring challenge is keeping the markup matching the visible reviews, since drift between the two is the number-one reason stars vanish.

This is exactly where generating markup from your live content helps. AI Schema Gen generates Review and AggregateRating markup on eligible item types from your actual page content, so your rating and count reflect what's genuinely visible, and stay in sync as reviews change, rather than a static block that drifts out of agreement after your next redesign. It also keeps you on the right side of the eligibility rules by generating markup that matches your content. For the review markup that most often breaks through drift, that automatic alignment is precisely the fix. Our Product schema guide covers the ecommerce review case in more depth. For the full picture of which types earn which rich results in 2026, see our schema types and rich results guide, and browse the full schema type directory for any type mentioned here.

Whatever route you take, the tests are: is it on an eligible type; do the numbers match the visible reviews exactly; are the reviews genuine and any incentives disclosed; and does it stay in sync as reviews change.

Star ratings, reviews, and AI

One forward-looking note: even where a review can't earn a Google star snippet, a local business reviewing itself, say, genuine review data still matters for AI search. AI systems that recommend businesses and products lean heavily on review signals and sentiment, drawing on independent platforms and your broader reputation. So the honest strategy is the same one that's good for everything: earn genuine reviews on the platforms that matter, keep them authentic, and represent them accurately. That builds the trust that earns stars where eligible and feeds the AI systems increasingly making recommendations, even where no star snippet appears.

Validating your review markup

Google's Rich Results Test confirms whether your review snippet is valid and eligible, and shows the parsed rating and count. Test your actual review pages and compare against what's visible.

Search Console has a review snippet enhancement report and, importantly, the Manual Actions report, where you'd see any penalty for policy violations like fake or undisclosed incentivized reviews.

The Schema Markup Validator checks general syntax.

The real test: open your page and confirm the rating and review count a visitor sees exactly match your markup. If they agree, you're on solid ground; if they don't, that's your fix before anything else.

Selling products, courses, or software on WordPress? AI Schema Gen generates Review and AggregateRating markup on eligible types from your content, matched to your visible reviews and kept in sync as they change, so your stars don't quietly vanish. Start free at aischemagen.com.