The Rich Results Test is Google’s main validation tool for checking which Google rich results a page may be eligible for. It is built for Google supported rich result features, not for every Schema.org type, and Google recommends it as the starting point for structured data testing. For generic Schema.org validation outside Google specific rich result checks, Google points publishers to the Schema Markup Validator instead.
If you want the wider schema hub first, start with Schema for SEO. If you need the markup format first, read JSON LD Basics. If your page is about a software product, pair this page with SoftwareApplication Schema. If the page is more commercial and offer led, compare it with Product Schema for SaaS.
The short answer
Use the Rich Results Test to check if a page or code snippet is eligible for Google rich results, to catch critical structured data errors, and to preview supported result features. Then use URL Inspection after deployment to see how Google reads the live page and its loaded resources.
What the Rich Results Test checks
The tool is built around Google supported rich result features. You can test either a URL or a code snippet, and the output can show detected items, errors, warnings, and a preview for many supported result types. Google says errors can block eligibility, while warnings can still leave a page eligible but may limit how the result appears.
That distinction is useful in production work:
- Errors mean the markup is not ready for the targeted feature.
- Warnings mean the markup may still qualify, though some elements can be missing from the final presentation.
- Preview is a directional check, not a promise of display in search.
What it does not check
The Rich Results Test is not a full Schema.org validator. If you are marking up a type that Google does not use for a rich result, or you want syntax validation without Google feature rules layered on top, Google points to the Schema Markup Validator for that job. Google also says a valid test does not guarantee a rich result in search, because feature display still depends on page quality, query context, device, location, and other ranking and presentation systems.
That is a good reason to keep this page close to Entity Markup and the wider Schema hub. Passing the test is one check, not the whole workflow.
The clean validation workflow
A simple workflow keeps the tool useful without giving it too much authority.
1. Test the code before publish
Run the page URL or paste the code snippet into the Rich Results Test. Review detected items, then fix every critical error before release. Google’s feature documentation repeats this pattern across rich result types: add the required properties, follow the feature rules, validate, then correct critical issues first.
2. Check that the markup matches visible content
Google’s structured data policies say the markup must represent the page’s main content, must not describe hidden content, and must not be misleading or irrelevant to the page focus. A page can pass syntax checks and still fail quality checks if the on page content and markup do not line up.
3. Publish a small batch first
Google’s documentation for rich result implementations recommends deploying a few pages, then checking how Google sees them with URL Inspection. That lets you confirm crawl access, loaded resources, and live page visibility before you scale the pattern across a larger cluster.
4. Inspect the live URL after deployment
The Rich Results Test is strong for pre publish validation. URL Inspection is the next step after release because it shows the current indexed or live status of the page in Search Console, along with crawl and resource details.
5. Watch for feature specific reports
For supported types, Search Console can surface enhancement reporting that helps track markup issues across published pages. That turns one page validation into an ongoing monitoring loop.
What counts as a passing page
A page is in better shape for Google rich results when five things line up:
- the markup uses a supported format such as JSON LD, Microdata, or RDFa
- the page is accessible to Google and not blocked by
robots.txt,noindex, or login walls - required properties are present for the targeted feature
- the structured data matches the visible page content
- the page follows the feature rules and Google’s broader structured data policies
For most SEO teams, JSON LD is the cleanest format to work with because Google recommends it, and it keeps the markup separate from the HTML body.
What the test can miss
Google says the Rich Results Test catches most technical errors, not every issue that can block display. A page can still miss rich results if the markup is misleading, hidden from users, incomplete in a way the tool did not catch, or not representative of the page’s main content.
That is why this page belongs inside the schema cluster, not as a one step fix. Test output has to be read next to page purpose, entity clarity, and on page content quality.
Rich Results Test vs Schema Markup Validator
These tools sit next to each other, but they do different jobs.
Use Rich Results Test when you want to know:
- is this page eligible for a Google rich result
- are there critical feature errors
- what supported feature preview can Google generate
Use Schema Markup Validator when you want to know:
- is the Schema.org syntax valid
- does this code validate even if Google does not support it as a rich result type
Google’s own documentation draws that line very clearly.
Current limits you should know
This tool only checks Google rich result features that Google currently supports, and that set can change. Google deprecated How to rich results in Search in 2023 and said support for How to was being dropped from the Rich Results Test.
In 2025, Google also announced that several types phased out from Search would be removed from Search Console reporting and the Rich Results Test, including Course Info, Claim Review, Estimated Salary, Learning Video, Special Announcement, and Vehicle Listing.
So if the tool does not validate a markup type you expected, the first question is not “did the code fail?” The first question is “does Google still support this rich result type in Search?”
A practical example for SaaS pages
On a SaaS site, the Rich Results Test is most useful when the page role is already clear.
For example:
- product page → test product markup and commercial fields
- software page → test software markup and entity clarity
- review page → test review specific markup
- article page → test article markup if that feature is supported
That is why pages like SoftwareApplication Schema, Product Schema for SaaS, and Review Snippet Rules sit so close together in the cluster. The test is only as good as the page type choice behind it.
Common mistakes
Treating the test as a ranking tool
The Rich Results Test checks eligibility and markup quality for supported features. It does not tell you if the page will rank, and Google does not promise feature display even for valid markup.
Validating code that does not match the page
Google’s rules are clear here: hidden, misleading, or irrelevant structured data can stop a page from showing as a rich result even when the syntax is clean.
Skipping URL Inspection
Pre publish testing is one step. Post publish inspection is another. Search Console gives you the live or indexed view that the Rich Results Test alone cannot replace.
Expecting every Schema.org type to validate in the tool
Google says the Rich Results Test is for Google rich result features. For generic Schema.org validation, use the Schema Markup Validator.
A short publish checklist
Before you ship markup on a live URL, check this:
- the page has one clear primary purpose
- the markup type fits that page purpose
- the structured data matches visible content
- the page is crawlable and indexable
- the Rich Results Test is clear of critical errors
- the live URL passes inspection in Search Console
Final take
The Rich Results Test is the right first stop for Google rich result validation. It is fast, feature specific, and strong at catching critical markup errors before release. It is not a full Schema.org validator, and it is not a guarantee that Google will show a rich result. The clean workflow is simple: test the code, fix the critical issues, publish a small batch, inspect the live URLs, then scale the pattern across the site.
FAQ
Can I use the Rich Results Test for any Schema.org type?
No. Google positions it as a test for Google supported rich result features. For generic Schema.org validation, use the Schema Markup Validator.
Does a valid result mean Google will show the feature?
No. Google says valid structured data can make a page eligible, but display is not guaranteed.
Should I test a code snippet or a URL?
Either can work. Google says the tool accepts both a code snippet and a page URL.
When should I use URL Inspection instead?
Use URL Inspection after deployment to see how Google reads the live page or indexed page and to review crawl and resource details.
What should I read next?
Go to JSON LD Basics, Schema for SEO, or Review Snippet Rules.