Rich Results Test

On this page 7

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 modeWhat is testedBest used for
URL testThe live page as rendered by GooglebotVerifying production pages after release
Code testPasted HTML or a JSON-LD snippetChecking markup before deployment
Smartphone crawlerMobile rendering, the default settingMatching mobile-first indexing
Desktop crawlerDesktop renderingDebugging desktop-only template differences
Input modes of the tool

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 stateMeaningRequired action
Valid itemMeets all required propertiesNone, although adding recommended fields may help
Valid with warningsEligible, but recommended properties are missingAdd missing fields where data is available
Invalid itemA required property is missing or malformedFix before the item can qualify
No items detectedNo supported rich result type foundCheck syntax, rendering or the chosen type
Result states and their meaning

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.

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.

ToolMain question answeredScope
Rich Results TestIs this page eligible for Google rich resultsOnly types Google supports as search features
Schema Markup ValidatorIs this markup valid Schema.orgAll Schema.org types and properties
Rich result status reportsHow valid is markup across the whole siteIndexed pages, aggregated by type
URL Inspection toolHow Google sees this indexed URLSingle URL, including indexing status
Comparison of structured data testing tools

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.

MisconceptionActual behavior
Valid means displayedValid only means eligible for display
All schema types are testedOnly Google-supported feature types are reported
Passing once is enoughTemplate or plugin changes can break markup later
Warnings must all be clearedWarnings are optional if the data does not exist
Misconceptions and the actual behavior

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.