The Rich Results Test is a free Google testing tool that analyzes a URL or code snippet and reports which Google rich result types its structured data qualifies for, together with any errors and warnings that block or limit eligibility. In SEO work with structured data, it is the standard way to confirm that markup in JSON-LD, Microdata or RDFa is readable by Google and meets Google’s feature-specific requirements.
The tool answers a narrow question: can this page be eligible for an enhanced search appearance such as review stars, product details or breadcrumbs? It does not promise that Google will show a rich result, and it does not validate every Schema.org type, which is why practitioners pair it with other checks.
How the Rich Results Test evaluates a page
The Rich Results Test fetches the page with Googlebot, renders it including JavaScript, extracts the structured data and compares each detected item with the documented requirements for the matching Google search feature. The result lists every detected rich result type with a status for each item.
Because the tool renders the page, it also catches structured data injected by JavaScript, for example markup added by a tag manager or a client-side framework. This makes it more realistic than a plain source-code validator, but it also means that blocked resources, slow scripts or server errors can produce incomplete results.
Users can test in two modes, and the choice affects what the tool sees. The table below summarizes the input options.
| Input mode | What is tested | Best used for |
|---|---|---|
| URL test | The live page as rendered by Googlebot | Verifying production pages after release |
| Code test | Pasted HTML or a JSON-LD snippet | Checking markup before deployment |
| Smartphone crawler | Mobile rendering, the default setting | Matching mobile-first indexing |
| Desktop crawler | Desktop rendering | Debugging desktop-only template differences |
Reading errors, warnings and valid items
The report sorts each detected item into one of three states, and the distinction between errors and warnings is the most important thing to understand. An error makes the item ineligible; a warning only reduces how complete the rich result can be.
| Result state | Meaning | Required action |
|---|---|---|
| Valid item | Meets all required properties | None, although adding recommended fields may help |
| Valid with warnings | Eligible, but recommended properties are missing | Add missing fields where data is available |
| Invalid item | A required property is missing or malformed | Fix before the item can qualify |
| No items detected | No supported rich result type found | Check syntax, rendering or the chosen type |
Typical errors include a missing required property such as a product name, an incorrect value type such as text where a number is expected, or an invalid date format. Warnings often concern recommended fields such as an image, a brand or aggregate ratings that the page simply does not have.
A practical rule is to fix every error and fill warnings only with truthful, visible data. Adding invented ratings or prices to silence a warning violates Google’s structured data guidelines and can lead to a manual action.
Rich Results Test versus related validation tools
The Rich Results Test checks Google eligibility, whereas the Schema Markup Validator checks general Schema.org conformance. The two tools answer different questions, and a page can pass one while failing the other.
| Tool | Main question answered | Scope |
|---|---|---|
| Rich Results Test | Is this page eligible for Google rich results | Only types Google supports as search features |
| Schema Markup Validator | Is this markup valid Schema.org | All Schema.org types and properties |
| Rich result status reports | How valid is markup across the whole site | Indexed pages, aggregated by type |
| URL Inspection tool | How Google sees this indexed URL | Single URL, including indexing status |
Teams that use types without a Google search feature, such as many Organization or niche schema properties, should rely on the Schema Markup Validator for those. For features Google does support, such as Product schema, Review snippet or BreadcrumbList, the Rich Results Test is the authoritative pre-release check.
Using the tool in a release workflow
The Rich Results Test is most effective as a checkpoint in the deployment process, not as an occasional manual check. Developers test new templates in code mode, then verify one representative URL per template after release.
- Test one URL per template, because structured data is usually generated at template level.
- Re-test after CMS, plugin or theme updates, which often change or duplicate markup.
- Compare the rendered HTML shown by the tool with the expected output when items are missing.
- Monitor the site-wide status reports afterward, since the tool tests only one page at a time.
The tool also offers a preview of some rich results, which helps stakeholders see what an eligible result could look like. The preview is illustrative only and does not reflect the exact layout Google will use.
Limitations and common misconceptions
The most widespread misconception is that a valid result guarantees a rich snippet. Google decides algorithmically whether to display a rich result based on query, device, site quality and policy compliance, so valid markup is necessary but not sufficient.
| Misconception | Actual behavior |
|---|---|
| Valid means displayed | Valid only means eligible for display |
| All schema types are tested | Only Google-supported feature types are reported |
| Passing once is enough | Template or plugin changes can break markup later |
| Warnings must all be cleared | Warnings are optional if the data does not exist |
Google has also retired or restricted several rich result types over time, including limits on FAQ and HowTo displays. When a type disappears from the report, the markup may still be valid Schema.org but no longer produces a feature, which is a policy change rather than a markup error.
In simple terms
The Rich Results Test is like a pre-flight inspection for the hidden labels that tell Google what a page contains, such as a price, a rating or a recipe time. It reads those labels and reports whether they are filled in correctly.
If the inspection passes, the page can receive a fancier listing in search results, with stars or extra details. Passing does not force Google to show that listing, but failing almost always rules it out.
A practical example
An online bookstore adds Product schema with prices, availability and customer ratings to 3,000 book pages generated from a single template. Before release, a developer pastes the JSON-LD from one page into the Rich Results Test in code mode and sees an invalid item: the price is written as text with a currency symbol instead of a number.
After the template is corrected, the test shows valid items with one warning for a missing global identifier, which the store adds from its ISBN data. Following release, the team tests a live URL, confirms that Googlebot renders the markup, and watches the site-wide product report.
Within about three weeks, most book pages show price and availability details in search results, and the report lists zero invalid items, giving the team a reliable baseline for future template changes.