Is this the same as Google's own Rich Results Test?

No, and it doesn't replace it. This tool only checks that your JSON-LD parses and extracts the fields needed for a visual mockup of four common types; Google's Rich Results Test actually validates against Google's live eligibility rules and tells you whether a specific URL is eligible to earn a rich result at all. Use this while drafting markup for a quick visual sanity check, then confirm with Google's own tool before shipping.

My JSON-LD is valid, so why does the preview say the type isn't supported?

This tool only builds a dedicated mockup for five @type values: Review, AggregateRating, FAQPage, BreadcrumbList, and Recipe (plus any type with an embedded aggregateRating, like Product). Valid JSON-LD of any other type, such as Article or LocalBusiness, is still syntactically fine, it just doesn't have a rich-result mockup built for it here - see the structured-data-validator tool for general-purpose field validation across more types.

Does having valid markup guarantee my page will show this rich result in Google?

No. Valid, complete structured data is necessary but not sufficient - Google also weighs content quality, overall site reputation and E-E-A-T signals, policy compliance, and plain algorithmic discretion before deciding whether to show any rich result at all, and it can stop showing one it previously granted. Treat markup as making you eligible, not entitled.

Why doesn't the star rating preview match what I see on Google exactly?

Google's actual rich result design changes over time and varies by result type, query, device, and ongoing A/B tests, and it isn't publicly documented as a fixed spec. This mockup approximates a plausible, representative layout for each type; treat the exact pixels, spacing, and colors as illustrative, not a guarantee of what Google currently renders.

Rich Result Preview - Mock Up JSON-LD as a Google Rich Result

Overview

Introduction

Structured data that's technically valid JSON can still be hard to picture: knowing that an FAQPage schema is well-formed doesn't tell you what the accordion will actually look like once (or if) Google decides to render it.

This tool bridges that gap for a handful of common types, turning pasted JSON-LD into a visual mockup so you can sanity-check the shape and content of a rich result before waiting on Google to index the page and maybe show one.

What Is Rich Result Preview?

A JSON-LD parser paired with a visual mockup renderer for five rich result shapes: a star-rating snippet (Review or AggregateRating, including one embedded inside another type like Product), an FAQ accordion (FAQPage), a breadcrumb trail (BreadcrumbList), and a recipe card (Recipe).

For any other @type, it says so plainly rather than guessing at a generic layout, since a fabricated preview for an unsupported type would be actively misleading about what that markup actually produces.

How Rich Result Preview Works

Pasted text is parsed as JSON, then the first usable node is found (a single object, the first object in an array, or the first entry in an "@graph" array), and its @type is read to decide which mockup, if any, to render.

Each supported type has its own small extractor that pulls just the fields that mockup needs, ratingValue and bestRating for a star snippet, question/answer pairs for an FAQ accordion, position-ordered breadcrumb names, or a recipe's name/rating/time - and renders them live as you type, with no fetch or validation step required first.

When To Use Rich Result Preview

While drafting Review, FAQPage, BreadcrumbList, or Recipe JSON-LD, to see roughly what shape of rich result it's aimed at producing before publishing.

When reviewing an existing page's structured data during an SEO audit, to quickly visualize what markup is present without manually reading raw JSON.

Often used alongside Structured Data Validator, FAQ Schema Generator and Review Schema Generator.

Features

Advantages

Renders instantly from pasted JSON-LD with no need for the page to be live, indexed, or fetched, unlike testing against Google's own live index.
Explicitly declines to fabricate a preview for unsupported types instead of showing a generic, misleading mockup for structured data it doesn't actually understand.
Also picks up an aggregateRating embedded inside another type like Product, since that's the part Google's rich result would surface as stars even when the outer type itself isn't separately supported.

Limitations

Valid, complete markup here doesn't guarantee Google will show a rich result for the real page - eligibility also depends on content quality, site reputation, policy compliance, and Google's own discretion, none of which this tool can evaluate.
The visual design shown approximates, not replicates, Google's actual (frequently changing, undocumented, and result-type-specific) rich result UI - use it to sanity-check structure and content, not to predict exact pixels.

Examples

FAQPage JSON-LD rendered as an accordion

Input

{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Is shipping free?","acceptedAnswer":{"@type":"Answer","text":"Yes, on orders over $50."}}]}

Output

Detected type: FAQPage. Preview: one accordion item, question "Is shipping free?" expandable to reveal "Yes, on orders over $50."

The mainEntity array's single Question/acceptedAnswer pair becomes one expandable row in the FAQ accordion mockup.

Best Practices & Notes

Best Practices

Run pasted markup through the structured-data-validator tool first to catch missing required fields; this preview assumes reasonably complete data and will just show blanks or fall back to defaults for anything missing.
Confirm real rich result eligibility with Google's own Rich Results Test and Search Console before relying on any markup to produce a specific result in live search.

Developer Notes

Rating scale is normalized on display but not on input: a bestRating of anything other than 5 (some sites use a 10-point scale) is read as-is and shown alongside ratingValue rather than rescaled, since silently rescaling a value the source data didn't ask for would misrepresent it.

Rich Result Preview Use Cases

Visually sanity-checking FAQPage, Review, BreadcrumbList, or Recipe JSON-LD while writing it by hand
Reviewing a page's existing structured data during an SEO audit without manually parsing raw JSON
Demonstrating to a non-technical stakeholder what a piece of structured data is roughly aiming to produce

Common Mistakes

Assuming a rendered preview here means the real page is guaranteed to show that rich result in Google, when eligibility depends on many factors this tool can't evaluate.
Pasting an entire HTML page instead of just the JSON-LD script contents; this tool expects raw JSON (or JSON inside a top-level array or @graph), not markup wrapped in a <script> tag.

Tips

If the preview says a type isn't supported but you know it has an aggregateRating property (like a Product), check that the property name and nesting match schema.org's exact structure, since a typo'd key won't be found.

Rich Result Preview