How to Test Structured Data: Rich Results Test, Validator, and Search Console
Testing structured data is not one check, it is three, and they answer different questions. The Rich Results Test tells you whether Google considers a page eligible for a rich result. The Schema.org validator tells you whether your JSON-LD is syntactically valid schema, regardless of what Google supports. And the Search Console enhancement reports tell you what is actually happening across your live, indexed pages over time. Use the first two while you build, and the third to monitor production.
If you have not added the markup yet, start with our guide on how to add schema markup and generate a valid block with the Schema Markup Generator, which validates as it produces the JSON-LD. This post is about verifying markup that already exists.
Layer one: the Rich Results Test
Google's Rich Results Test (search "Rich Results Test" or go to the Search Console family of tools) answers the question that matters for SEO: is this page eligible for a rich result, and which one? You paste a URL or a code snippet, and it renders the page the way Googlebot does, then reports the structured data types it detected and whether each is valid.
The important detail is that it renders JavaScript. If your markup is injected client-side, the Rich Results Test will often still find it, because it runs the full render. That is useful, but it can mask a problem: the test passing does not prove the markup is in your served HTML. Use the URL mode to test the live page, and use the code mode to test a block before you deploy it.
The Rich Results Test only reports on structured data that is tied to a Google rich result feature. If you add a valid schema type that Google does not use for rich results, the test will say it found no eligible items, which is not an error. That is where the second tool comes in.
Layer two: the Schema.org validator
The Schema.org validator (validator.schema.org) checks a different thing: is this valid schema.org markup, by the vocabulary's own rules? It does not care whether Google shows a rich result for it. It parses your JSON-LD, lists every type and property it found, and flags anything that is not a recognized property for that type.
Use this when the Rich Results Test says "no items detected" but you are sure you added markup. The validator will show you what it actually parsed, which usually reveals the problem: a typo'd type name (Artical instead of Article), a property nested at the wrong level, or a JSON syntax error breaking the whole block. It is the tool for "is my markup well-formed at all," where the Rich Results Test is "will Google do anything with it."
Layer three: Search Console enhancement reports
The first two tools test one page at a time, on demand. Search Console tests every page Google has crawled, continuously, and it is the only one that reflects your real indexed state. In Search Console, structured data shows up under the enhancement reports, listed by type in the left navigation (you will see entries like "Breadcrumbs," "FAQ," "Products," "Merchant listings") once Google has detected that type on your site.
Each report splits your URLs into invalid, valid with warnings, and valid. When you fix an issue, you use the "Validate Fix" button, and Google re-crawls the affected URLs and tracks whether the errors clear. This is the layer that catches problems the single-page tools miss: a template change that broke markup on 4,000 product pages shows up here as a spike in invalid items, days before you would notice it any other way. Check it after any deploy that touches templates.
What the errors and warnings mean
The distinction that trips people up is errors versus warnings.
An error means the markup is missing something Google requires for that rich result type, and the page is not eligible. "Missing field 'image'" on an Article, or "Missing field 'price'" on a Product offer, means Google will not show the rich result until you add that property. Errors block eligibility.
A warning means a recommended property is missing, but the page is still eligible. "Missing field 'aggregateRating' (optional)" is a warning: adding ratings would make a richer result possible, but the page qualifies without it. You do not have to clear every warning. Add the ones that map to something real on your page and ignore the rest.
Here is how the common Article and Product messages break down:
| Message | Type | Meaning | | --- | --- | --- | | Missing field "image" | Error | Required property absent; not eligible | | Missing field "author" | Error | Required for Article; add it | | Missing field "aggregateRating" (optional) | Warning | Recommended only; page still eligible | | Unparsable structured data | Error | JSON syntax is broken; whole block ignored | | Invalid value in field "priceCurrency" | Error | Value present but wrong format (use ISO codes like USD) |
When you see "unparsable structured data," go straight to the Schema.org validator, because that is a syntax problem, not a missing-field problem.
Why previews pass while production fails
This is the failure mode we see most, and it has one root cause: the markup is added by JavaScript, and the served HTML does not contain it.
The Rich Results Test renders JavaScript, so it sees the client-injected markup and passes. Then you check the live page with "view source" or a curl request, and the JSON-LD is not there, because it only appears after the browser runs your scripts. Some crawlers and some of Google's own pipelines read the raw HTML, so you get intermittent detection: it works in the test, it is missing in Search Console.
To catch this, do not rely only on the render-based test. View the page source (right-click, View Page Source, or curl -s https://yourpage | grep ld+json) and confirm the block is in the raw HTML. If it is not, move the markup server-side. The same problem explains meta tags that vanish from social previews, which we cover in the Open Graph checker guide if you are debugging both at once.
A second, quieter reason production fails: the markup describes content that is not on the page. Google's policies require the structured data to match visible content, so FAQ markup for questions the page does not show, or a review count the page does not display, can be flagged or earn a manual action even though the syntax is perfect. The test tools check syntax and eligibility; they do not check whether you are telling the truth about the page.
A testing routine that holds up
Generate and pre-validate the block, deploy it, run the live URL through the Rich Results Test, confirm the block is in your served HTML with view-source, then watch the Search Console enhancement report for that type over the next week. If the report shows valid items climbing and no error spike, the markup is working in production, which is the only place that counts.
Frequently Asked Questions
What is the difference between the Rich Results Test and the Schema.org validator?
The Rich Results Test checks whether Google considers your page eligible for a specific rich result feature, and it ignores valid schema types Google does not use. The Schema.org validator checks whether your JSON-LD is well-formed schema by the vocabulary's own rules, regardless of Google support. Use the validator when the Rich Results Test says it found nothing but you know you added markup.
Do I need to fix every warning in the structured data report?
No. Warnings flag recommended properties that would enable a richer result, but the page is already eligible without them. Errors block eligibility and must be fixed; warnings are optional. Add the recommended properties that correspond to real content on your page and ignore the ones that do not apply.
Why does my structured data pass the test but not appear in Search Console?
The most common cause is client-side injection: the Rich Results Test renders JavaScript and sees the markup, but your served HTML does not contain it, so other crawl paths miss it. Check with view-source or curl, and if the block is missing from the raw HTML, render it server-side.
How long does Search Console take to show structured data?
It appears after Google crawls and processes the pages carrying that type, which can take days to a few weeks for a new site or a new type. The enhancement report for a type only shows up once Google has detected that type at least once on your site.
Can valid structured data get a manual action?
Yes. Syntactically perfect markup can still violate Google's structured data policies if it describes content that is not visible on the page, such as fake reviews or FAQ answers the page does not show. The test tools verify syntax and eligibility, not honesty, so keep your markup matched to visible content.