JSON-LD Review Schema Generators Compared: Which One Actually Validates?
If you searched "json ld review generator," you want code you can paste and trust, not another explainer on schema.org vocabulary. Fair. The problem is that "generates JSON-LD" and "generates JSON-LD that earns star ratings" are two different bars, and most generators only clear the first one.
We know this because we crawled it. TheWebRatings' 2026 review schema study checked JSON-LD on 985 reachable SaaS marketing homepages: 53.9% ship some JSON-LD, but only 10.7% of that markup validates with no issues at all, and 17.1% carries outright errors of the kind that blocks a rich result. A generator that only checks JSON syntax will wave all of that through, because syntax was never the failure mode. This post compares the four ways teams actually produce review markup today, then walks through generating a validated block in a few minutes. For the structural rules behind all of it, see the review schema and structured data guide.
What a review schema generator actually has to get right
A syntax-valid AggregateRating block can still fail to earn a star rating for three reasons a JSON linter never checks:
- Nesting.
AggregateRatinghas to sit inside the entity it rates (SoftwareApplication,Product,Organization), not float on its own. Get the parent type wrong and Google finds no eligible item to attach stars to. - The self-serving rule. Google has excluded ratings an entity publishes about itself on
OrganizationorLocalBusinessmarkup since 2019. A generator that doesn't flag this will produce markup that validates perfectly and never shows a star. We cover the full mechanics in how to add AggregateRating schema. - Count requirements. At least one of
ratingCountorreviewCountis required, and a zero or missing count invalidates the item outright rather than just triggering a warning.
None of these are visible in a generic "is this valid JSON" check, which is exactly why markup that passes a syntax validator can still lose its stars overnight. We've seen this happen even on sites that never touched their schema; see why star ratings disappeared from Google for the eligibility side of that story.
Four ways teams generate this markup, compared
| Approach | Review-specific fields | Warns on self-serving markup | Live validation | Cost |
|---|---|---|---|---|
| Hand-coded from a template | Manual, error-prone | No | No | Free (your time) |
| General-purpose schema generator | Generic, dozens of types | No | Syntax only | Free |
| Google's Structured Data Markup Helper | Limited, largely superseded | No | No | Free |
| Dedicated review schema generator | Purpose-built, four entity modes | Yes | Yes, against required and recommended fields | Free |
Hand-coded. Fine if you already know the property list cold and re-check it every time reviews change. Most teams don't, which is how the 17.1% error rate above happens: a copied template with the wrong ratingCount/reviewCount pairing, or a scale mismatch between ratingValue and bestRating.
General-purpose schema generators. Tools like technicalseo.com's Schema Markup Generator cover dozens of schema.org types with clean, free JSON-LD output, and they're a reasonable choice for FAQ or Article markup. For reviews specifically, they generate whatever fields you fill in without knowing schema.org's review-specific eligibility rules, so a well-formed but self-serving or under-counted block sails through unflagged.
Google's own tools. Google's Structured Data Markup Helper still exists but Google itself steers you elsewhere now: the company retired its Structured Data Testing Tool in 2020 and its replacement landing page points visitors to the Rich Results Test instead. The Rich Results Test is worth running on anything you ship (we walk through it in a practical debugging walkthrough), but it validates markup someone else generated; it doesn't build the block for you.
Dedicated review schema generator. Purpose-built tools check the review-specific rules above in addition to JSON syntax. Ours (disclosure: we build one, judge accordingly) is the Review Schema Generator: four modes for SoftwareApplication, Product, Organization, and standalone Review, with the self-serving warning built into the Organization mode and the same validation logic as our JSON-LD validator running live under the form.
Step-by-step: a validated block in under five minutes
- Pick the entity type. SaaS apps almost always want
SoftwareApplication; useProductfor a page selling a specific plan or bundle,Organizationonly if you understand the self-serving trade-off, and standaloneReviewwhen you're marking up a single testimonial rather than an aggregate. - Fill the required fields. Name, URL, and the rating value are non-negotiable; the form nests everything correctly so you never have to remember whether
reviewCountgoes on the rating or the parent item. - Fix the warnings. Missing recommended fields (
bestRating,worstRating, anoffersblock for apps) show as warnings before you ever paste the code anywhere. - Copy the script tag. Drop it into your page's head or body, then run it through the Rich Results Test on the live URL, since deploy pipelines occasionally mangle a script tag that looked fine locally.
For the full property-by-property reference, including exactly what "required" versus "recommended" means for each field, see the SoftwareApplication schema property reference.
Generating once isn't the same as staying correct
Every generator above, including ours, has the same blind spot after the first paste: none of them know when your rating changes next month. A block generated once and hardcoded into a template will silently drift from the number displayed on the page as new reviews arrive, and drift is a guidelines violation that never throws an error. It just quietly stops earning the star.
The fix is generating from the same data source that renders the visible rating, not from a one-time form submission. That's the gap a generator tool can't close on its own, and it's the reason review platforms exist: TheWebRatings publishes SoftwareApplication, AggregateRating, and Review markup on an independent public page, regenerated from live verified review data on every request, which also sidesteps the self-serving rule entirely because the page publishing the rating isn't the page being rated. It's free for one website.
Which generator fits your situation
If you're marking up a one-off Article or FAQ page, a general-purpose generator is the right tool and overkill isn't warranted. If you're marking up reviews or ratings anywhere, use something that knows the review-specific rules (ours or your own careful reading of the property reference above), and always finish with the Rich Results Test regardless of what generated the block. If the rating itself changes over time, which for any active SaaS product it will, generate it from live data rather than a static form submission, or hand that chore to a platform built to do it continuously.
Frequently asked questions
No. A generator gets you valid, well-nested markup, which is necessary but not sufficient. Google still decides eligibility per query, and the two most common silent blockers, self-serving markup and a rating that doesn't match visible page content, are eligibility problems no generator or validator can fully catch for you.
A generator builds the JSON-LD from your inputs; a validator checks JSON-LD you already have against structural rules. The Rich Results Test and validator.schema.org are validators. Most tools marketed as "generators," including general-purpose ones, only validate JSON syntax rather than schema.org's business rules, which is why running a dedicated validator afterward is still worth the extra minute.
You can, and it will produce syntactically valid output. It won't warn you about the self-serving rule, won't enforce the ratingCount/reviewCount requirement, and won't nest the rating under the right parent type automatically the way a review-specific tool does. For a quick one-off it's fine as long as you know the rules yourself; for anything you'll maintain, a dedicated tool catches mistakes a generic one won't flag.
Not really. Google's Structured Data Markup Helper still runs but is largely superseded, and Google's current guidance for checking structured data points to the Rich Results Test, which validates rather than generates. There's no first-party Google tool purpose-built for review or rating markup.
Run it through the Rich Results Test on the live, deployed URL, not a local copy. Check that the rating and review count shown in the markup match what a visitor can actually see on the page, and confirm the page isn't Organization or LocalBusiness markup rating your own company (the self-serving exclusion). Then watch Search Console's Review snippets report after deployment for anything the test missed.
Regenerate it, or better, generate it from the same field that renders the visible rating so it never goes stale. A one-time paste is fine for a page whose rating will never change; for an actual product with an actual review count, hardcoded markup drifts out of sync within weeks and the failure is invisible until someone notices the stars are gone.