Google’s Rich Results Test tells you two things: whether Google can fetch and render your page, and whether the structured data on it qualifies for a rich result Google currently supports. Read the report from the top down. Check the status line, then the crawl details, then each detected item. Errors on an item block eligibility. Warnings don’t.
Some panels are easy to misread. “No items detected,” for example, often doesn’t mean your markup is missing. Last checked: October 30, 2026.
What the Rich Results Test Checks
The test fetches a URL or takes pasted code, renders it, extracts structured data in JSON-LD, RDFa or Microdata, and compares it with Google’s requirements for each rich result feature. Google’s Rich Results Test help page says it shows “which rich result types were found on the page, as well as any errors or suggestions for your structured data.”
It doesn’t validate schema.org in general. When Google refocused the old Structured Data Testing Tool and moved it to schema.org, general validation became the Schema Markup Validator’s job. The Rich Results Test only reports on types that can produce a Google feature. Our schema validator guide compares the two tools in depth.
A valid result isn’t a promise either. Google’s structured data guidelines say it “does not guarantee that your structured data will show up in search results, even if your page is marked up correctly according to the Rich Results Test.”
Testing by URL vs Code Snippet
URL is the realistic test. Google fetches the live page as an anonymous visitor, and the help page notes that all resources “must be accessible by an anonymous user accessing the code from the internet.” Pages behind a login or firewall, or on localhost, need a tunnel.
Code lets you paste HTML or a JSON-LD block, edit it and rerun as often as you like. Use it to check output from a schema markup generator before it ships. Two caveats:
- The tool ignores comments inside JSON-LD, but Google warns the JSON-LD standard doesn’t support them. Strip them before publishing.
- For JavaScript-generated markup, Google’s guide to generating structured data with JavaScript recommends the URL input “because there are JavaScript limitations when using the code input (for example, CORS restrictions).”
Below the input you can pick the user agent. Smartphone is the default. Switch to desktop when your desktop and mobile pages serve different HTML, or when the feature is desktop-only. Breadcrumbs are one: Google’s documentation changelog notes that since January 2025 they appear only in desktop results.
The Status Line: Valid, Warnings, Invalid
The report opens with an overall verdict. The help page lists every status, where N is the number of items:
| Status | What it means | What to do |
|---|---|---|
| N valid item(s) detected | Required properties are present and correct | Nothing required |
| N valid item(s) with warnings detected | Eligible, but recommended properties are missing or off | Add the ones you can fill accurately |
| N items detected: Some are invalid | At least one item has a blocking error | Open each invalid item and fix it |
| N invalid item(s) detected | Every item has at least one blocking error | Fix syntax first, then required properties |
| Structured data with syntax errors detected | Part of the markup couldn’t be parsed | Fix the syntax before anything else |
| No items detected | No supported rich result markup found after rendering | See the troubleshooting section below |
| URL cannot be crawled | The fetch failed or was blocked | Read the crawl details |
An error means the item can’t get a rich result, usually because a required property is missing or has the wrong value type. Google’s guidelines put it plainly: “Items that are missing required properties are not eligible for rich results.”
A warning means a recommended property is missing or has a problem. The item stays eligible. Google says more recommended properties make “the higher quality the result is to users,” so they’re worth adding when you have accurate data, but they can wait until errors are fixed.
Detected Items
Under the status line, findings are grouped by type, such as Article, Breadcrumb, Product snippet, Merchant listings, Review snippet or Video. Expand an item to see the properties Google read, with issues flagged beside them.
Click an issue and the tool opens a code explorer at the line that caused it. The help page adds a detail that matters: “The explorer uses the rendered source code.” If a plugin, tag manager or script changed your markup after load, you’re looking at the final version, not your template.
Watch for:
- Duplicates. Two Breadcrumb or Product blocks often mean a theme and an SEO plugin both output markup.
- The wrong type. If you expected Product snippet and only see Breadcrumb, your product markup isn’t being picked up.
- Nested errors. An error on a nested review or offer still makes the parent item invalid.
The Crawl Details
This panel tells you whether the test reached the page. Per Google’s help page, it shows:
- Crawled successfully / Crawl failed. Whether Google got the page.
- Crawled as. Googlebot smartphone or desktop.
- Crawl allowed? Whether a robots.txt rule blocks the page.
- Page fetch. Whether the fetch worked. If crawling failed, this fails too.
The help page also says that if a page is blocked “by a robots.txt rule or noindex directive, the page cannot be tested with this tool.” For the noindex side, URL Inspection in Search Console has an explicit Indexing allowed? field. Its help page flags a trap: when robots.txt blocks a page, “Indexing allowed?” always reads “Yes,” because Google can’t see the noindex tag. Our robots.txt examples show rules that won’t block pages by accident.
When the page can’t be reached at all, the test reports an error. The ones you’ll see most:
- DNS server unresponsive or DNS error: Host unknown. Often temporary. Retry in a few minutes.
- Server connection error or Server invalid response. The server refused the connection, or sent truncated or unparsable data.
- Invalid server SSL certificate. Google won’t test an HTTPS URL with an invalid certificate.
- Robots.txt unreachable. If robots.txt exists but can’t be fetched, Google won’t crawl the site.
- Hostload exceeded. Google estimates your server is at capacity for its requests.
If the test fails but the page loads in your browser, check your firewall and CDN bot rules.
View Tested Page: HTML, Screenshot and More Info
After a URL test, View tested page opens the panel most people skip, and it often holds the answer. A Google Search Central Community guide on rendering notes it’s useful even for pages without structured data, since it shows how Googlebot renders content without Search Console access.
- HTML. The rendered HTML after JavaScript ran. Search it for
application/ld+json. If your JSON-LD isn’t there, Google can’t see it. This is the quickest JavaScript SEO check you can run on a page you don’t own. - Screenshot. The rendered page. A blank screen, a cookie wall over the content or a broken layout suggests scripts or CSS didn’t load.
- More info. Page resources and JavaScript console messages, including files that failed to load or were blocked by robots.txt.
Blocked resources matter because the test may then render the page differently from a real browser. The help page also warns that pages with unloadable resources can return “slightly different results every time you run the test.” A flaky result is often a resource problem, not a markup problem.
Preview and Sharing
For some types, Preview shows how the result might look in Google Search, with selectors for different layouts and for desktop or mobile. Google adds that it “does not guarantee that your page will appear exactly as shown here.”
Share creates a link anyone can open without permissions, valid for about 90 days. Search Console also saves your code and test state with each run. Bookmark the result URL to keep a version history for about 90 days, but note Google says these bookmarks are “accessible by anyone.” Keep confidential code out of tests you share.
Common Errors and How to Fix Them
Syntax errors in items of unknown type
Some errors stop the parser before it can tell what type the item is. Google groups them under “Syntax errors in items of unknown type.” The usual suspects:
- Invalid JSON document or Parsing error: Missing ‘,’ or ‘}’. A missing comma or brace, often from hand editing or a template that outputs an unescaped quote.
- Bad escape sequence in string. A backslash before a character that can’t be escaped.
- Duplicate unique property. Something that should appear once appears twice, such as
@context. - Incorrect value type or Invalid number. A string where a number or array was expected.
Fix these first. Nothing in a broken block counts until it parses.
Missing or invalid required properties
These show as errors on a specific item, such as a Product without name. Each feature’s page in Google’s structured data gallery lists what’s required. Check formats too: ISO 8601 dates, and a numeric price with the currency in priceCurrency.
No items detected
The most confusing result. Common causes:
- The markup uses a type Google doesn’t support as a rich result, such as
Service. If the Schema Markup Validator finds it, the markup exists but doesn’t map to a Google feature. - JavaScript that injects the markup failed during rendering. Check the HTML tab.
- The markup is for a retired feature (see below).
Problems the test can’t catch
Google’s guidelines list “the structured data is incorrect in a way that the Rich Results Test was not able to catch” among reasons a valid item may not show. The classic case is markup that doesn’t match the page, like a schema price that differs from the visible one. Google says not to “mark up content that is not visible to readers of the page,” and structured data issues can lead to a manual action even when the test passes.
Rich Results Test vs Schema Markup Validator vs Search Console
| Tool | Question it answers | Scope | Best for |
|---|---|---|---|
| Rich Results Test | Does this page or snippet qualify for a Google rich result? | One URL or snippet, any site | Building and debugging markup, testing pages you don’t own |
| Schema Markup Validator | Is this valid schema.org? | Any schema.org type | Types Google ignores, markup for other platforms |
| Search Console URL Inspection | What did Google index, and can the live URL be indexed? | One URL in a property you own | Confirming fixes, checking indexing and canonicals |
| Search Console rich result reports | How many valid and invalid items does the site have over time? | A sample of items across the property | Catching template or plugin breakage |
Schema.org describes its validator as “based on the tool previously known as the Google Structured Data Testing Tool” and says it can extract structured data injected by JavaScript.
Google’s rich result report overview explains that the Search Console reports count items, not pages, and show “a sample of detected items.” Each has a “Why items are invalid” table for critical issues and an “Improve item appearance” table for the rest. URL Inspection is also where you see the Google-selected canonical, which the live test can’t predict. If your canonical tag points somewhere unexpected, Google may be using structured data from a different URL.
Google’s introduction to structured data recommends the Rich Results Test during development and the status reports after deployment, because pages “might break after deployment due to templating or serving issues.”
Which Rich Results Still Exist
Google has retired many rich result features, and testing markup for one that’s gone wastes time. From the Search Central documentation updates:
- FAQ. Google said the feature “will no longer appear in Google Search starting May 7, 2026,” and removed its documentation in June 2026. Our FAQ schema guide covers whether the markup is still worth keeping.
- How-to. Google removed the documentation in September 2023 because the rich result no longer shows on desktop or mobile.
- Course info, ClaimReview, estimated salary, learning video, special announcement and vehicle listing. Announced for phase-out in Google’s June 2025 post on simplifying the search results page, then removed from Search Console reporting and the Rich Results Test starting September 9, 2025.
- Practice problems. Removal from Search Console reporting and the Rich Results Test was set for January 2026.
- Dataset. Clarified in November 2025 as used only by Dataset Search, not Google Search.
Help pages can lag the changelog. On October 30, 2026, the Rich Results Test help page still listed Practice Problems and Dataset as supported. When they disagree, trust the dated changelog entry.
Does Passing the Test Help in AI Search?
Not directly, and Google says so. Its guide to optimizing for generative AI features calls “overfocusing on structured data” a misconception: “Structured data isn’t required for generative AI search, and there’s no special schema.org markup you need to add.” It still recommends keeping structured data “as it helps with being eligible for rich results on Google Search.” Google’s AI features page lists making sure structured data matches the visible text on the page as a best practice.
Microsoft is warmer on it. Its October 2025 post on optimizing content for AI search answers calls schema “a type of code that helps search engines and AI systems understand your content.”
The more useful AI-visibility signal in the Rich Results Test is the crawl panel and View tested page. They show whether a crawler can fetch your page and see the content after JavaScript runs. Whether other AI crawlers are allowed in is a robots.txt question. Our AI crawler list covers the user agents to check.
Frequently Asked Questions
What is the Google Rich Results Test?
It’s a free Google tool that checks whether a page or code snippet has structured data eligible for Google rich results. It also shows how Google crawled and rendered the page, and previews some result types.
Is the Rich Results Test the same as a schema validator?
No. The Rich Results Test only reports on types that can produce a Google feature. The Schema Markup Validator checks any schema.org type, so use it when the Rich Results Test shows nothing for markup you know is there.
Do warnings stop a rich result from showing?
No. Warnings flag missing recommended properties, and the item stays eligible. Errors on required properties are what block a rich result.
Why does the Rich Results Test say “No items detected”?
Usually because the page uses types Google doesn’t support as rich results, the markup didn’t render, or it’s for a retired feature like FAQ. Check the HTML tab under View tested page, then try the Schema Markup Validator.
Can I test a page that isn’t live yet?
Yes. Paste the code into the Code tab, or expose a staging page through a tunnel. URL tests need the page and its resources to be reachable from the internet without a login.
Why does the test give different results each time?
Usually because some resources didn’t load. Google says unloadable resources can make results vary between runs, so check More info under View tested page.
Should I use the Rich Results Test or URL Inspection?
Use both. The Rich Results Test works on any URL and is better for debugging code. URL Inspection only works on sites you’ve verified, but it shows the indexed version, indexing status and the Google-selected canonical.
Can AI engines read your site?
Check any page for free: crawler access for ChatGPT, Perplexity, Claude and Google AI Overviews, plus the fixes that matter most.
