Schema.org Review markup, explained — and why it's quiet money

You've seen the difference in Google search results between a plain blue link and one with ⭐⭐⭐⭐⭐ underneath. The starred result wins clicks against the plain one almost every time — somewhere between +15% and +35% lift in click-through rate, depending on whose study you trust.

That star rating is not magic. It's a small piece of JSON pasted into your page's <head>. Google reads it, decides it's trustworthy, and renders the stars in the SERP. The mechanism is called schema.org Review markup — or, more formally, structured data.

This post is the practical version of Google's documentation: what to emit, what to skip, and the four mistakes that get you flagged and lose the rich result.

The minimum that works

Schema.org has dozens of fields you can include. Google actually reads about six. Here's the minimum useful payload — everything else is decoration:

JSON-LD (drop into <head>)

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Acme Pro",
  "url": "https://acme.com",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "127",
    "bestRating": "5",
    "worstRating": "1"
  },
  "review": [
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "Sarah Chen" },
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5",
        "bestRating": "5"
      },
      "reviewBody": "Best testimonial software we've used."
    }
  ]
}
</script>

Four notes about that payload:

@type can be Product, SoftwareApplication, LocalBusiness, or Organization. SaaS usually wants SoftwareApplication — but Google is more permissive with Product, so default to that unless you have a reason.
aggregateRating is what produces the stars. Without it, individual review entries won't render rich.
reviewCount must be ≥ 1 and the number must match something a human could verify on the page. Don't claim 12,000 reviews while showing 4.
worstRating and bestRating are optional but recommended — they tell Google the scale, instead of letting it guess.

What Google actually checks

Google's spam team is more aggressive about Review rich results than almost any other rich-result category, because the conversion-rate uplift makes them a magnet for abuse. Three checks they run:

1. Is the review visible on the page?

If the JSON-LD lists a review by “Sarah Chen” but no Sarah Chen quote appears anywhere on the visible page, that's the single most common reason rich results disappear. The markup must mirror what a visitor would read.

2. Is the rating self-serving?

Google explicitly says reviews of the page's own first-party entity on the same page are allowed (you reviewing your own SaaS on your own site is fine). What's not allowed: reviews of third-party products on a non-review page (e.g., an Amazon competitor page where you grade them 1/5). The rule is roughly: first-party praise on your own page is OK; third-party hit-pieces are not.

3. Does the count match reality?

If you say reviewCount: 500 but the page only shows five, Google will sometimes show stars anyway and sometimes not. If they flag you, the rich result vanishes for the whole domain. Don't inflate.

The four mistakes that lose the rich result

Putting the markup on a page that doesn't show the reviews. Most common cause. The markup is bound to the page URL — it has to live where the visible content lives.
Marking up reviews that aren't really reviews. “This article is great!” in a blog comment is not a Review of your product. It's a blog comment.
Aggregating across products you don't own. If your site reviews other people's SaaS tools, you can't render stars for them in your SERP — only the SaaS itself can.
Pasting and never updating. If you publish reviewCount: 12 on January 1, leave it for a year, and add 30 new testimonials in that time, Google can see the mismatch. Auto-generate the markup from the same source as the visible content.

How to verify it's working

Two free tools to validate:

Google Rich Results Test — paste a URL, see if it's eligible for stars.
Schema.org Validator — checks the JSON structure independent of Google's rendering choices.

After deploying, expect 7–30 days before stars show up in real searches. Eligibility isn't guaranteed even on perfect markup — it's a Google ranking decision. But for SaaS pages, with valid markup + visible content matching, the hit rate is high.

The shortcut

We built a free schema generator that produces valid JSON-LD from up to 5 reviews you paste in. Good for static pages, landing-page experiments, or just learning the shape.

If you want this to happen automatically — markup + visible content always in sync, new testimonials flowing in by themselves — that's what Plauditly does on every embed, starting from the Starter tier ($19/mo). The schema regenerates every time you approve a new testimonial. No manual paste.

The stars are worth the half hour it takes to add them.

Schema.org Review markup, explained — and why it's quiet money.