Schema test: how to check your structured data works
You’ve added structured data to your page, but how do you know if it works? Here’s how to run a proper schema test with Google’s Rich Results Test, the Schema.org validator and Search Console — plus how to fix the most common errors.
Published on · Updated on · 9 min read
Adding structured data to a page is only half the job. The other half — the one almost everyone skips — is running a schema test to check that Google can actually read it, that it doesn’t have errors and that it triggers the rich results you expected.
In this guide I’ll show you the three free tools I use on every audit to validate schema: Google’s Rich Results Test, the Schema.org validator and Search Console. And I’ll explain how to fix the most common errors that make a schema test fail.
What a schema test is and what it checks
A schema test is the process of checking whether the structured data on your page is technically valid and semantically correct. It’s not just about syntax: it’s about whether Google can understand the entity, whether it qualifies for rich results, and whether it matches the visible content on the page.
A good schema test checks five things:
- Syntax: the JSON-LD is well-formed and doesn’t have broken brackets or commas.
- Required properties: all mandatory fields for that type are present.
- Recommended properties: the optional fields that improve the result are included.
- Coherence with the visible content: the schema reflects what the user actually sees.
- Eligibility for rich results: the type is supported by Google and the page is a candidate.
If any of these fail, the schema won’t generate the rich result you’re aiming for — even if the code looks fine at first glance.
Google’s Rich Results Test
This is the first tool to use. Rich Results Test is Google’s official validator. It tells you whether your page qualifies for a rich result, and shows warnings about missing recommended properties.
How to use it:
- Go to search.google.com/test/rich-results.
- Paste the URL of your page or paste the HTML code directly.
- Click «Test URL» or «Test Code».
- Review the results: detected types, valid items, warnings and errors.
The result shows you which schema types Google has detected and whether they qualify for rich results. If you see «No items detected», something is wrong: either the schema isn’t loading, or the format isn’t correct.
One important detail: Rich Results Test only validates types that Google supports. Other types (like some from Schema.org) won’t appear even if they’re perfectly valid — you’ll need the second tool for that.
Schema.org validator
The Schema.org validator is more thorough: it checks the semantic and syntactic correctness of any type, whether or not Google uses it to generate rich results. This is what you use for a full test schema that covers all your structured data.
How to use it:
- Go to validator.schema.org.
- Paste the URL or the HTML code of your page.
- Review the report: it lists every type detected with all its properties.
Unlike Rich Results Test, this validator doesn’t just check what Google cares about: it checks what the schema vocabulary allows. That makes it perfect for detecting subtle issues, like a property in the wrong place or a value with the wrong type.
Good practice: use both tools. Rich Results Test to confirm the rich results, and the Schema.org validator to confirm that the markup itself is correct. If they both pass, you’re good.
Search Console’s Enhancements reports
The third pillar of a good schema test is Search Console. It won’t tell you if your schema is well written, but it will tell you if Google has detected errors on pages that are already indexed.
Where to look:
- Enhancements section: here you’ll see reports by type: Breadcrumbs, Articles, FAQ, Product, etc. Each one shows valid pages and pages with errors.
- URL Inspection: if you paste a specific URL, it tells you if the rich result was detected and if there are issues.
- Core Web Vitals: not about schema, but useful to check the technical state of the page.
The value of Search Console is that it works over time. It’s not a one-off test: it warns you if a schema that was working stopped being valid because of a template change, a CMS update, or a change in Google’s supported types.
Most common schema errors (and how to fix them)
These are the errors I see most often when I run a schema test on client pages:
1. Missing required properties
Every type has a minimum set of properties. For an Article,
for example: headline, image,
datePublished and author. If any of them is
missing, the rich result won’t appear. The fix is to check the
documentation for each type and complete the missing fields.
2. Invalid date formats
datePublished and dateModified must be in
ISO 8601: 2026-10-16T09:00:00+02:00. Writing
16/10/2026 makes the schema invalid. It’s a common mistake
with automated generators.
3. Images or URLs that return 404
The image, logo or url properties
must point to real, accessible URLs. Google checks them. If they return
a 404, the schema fails even if everything else is fine. Regularly check
your media library and set up redirects when you change an image.
4. Incorrect nesting of types
A common error is nesting a type where it doesn’t belong, for example
placing a Person as the value of publisher
when the value should be an Organization. The validator
detects it immediately.
5. Schema that doesn’t match the visible content
If you declare a Product with a price of €19 but the page
shows €29, Google will mark it as a mismatch. And if it repeats, it can
lead to a manual action. The rule is simple:
the schema must reflect what the user sees.
6. Using types that don’t generate rich results
Not every valid schema type generates rich results. If you’ve carefully written a schema that Google doesn’t support for rich results, you’ll never see it in search — regardless of how well you test it. Check the gallery of supported types before writing them.
Quick checklist before publishing
This is what I do every time I add or modify schema on a client page:
Run the Rich Results Test
Confirm the type is detected and no errors appear.
Run the Schema.org validator
Confirm there are no structural or semantic issues.
Check coherence with the visible content
The title, price, dates and images in the schema must match what the user sees.
Verify the URLs
Every image, url or logo property must return 200, not 404.
Monitor with Search Console
Once indexed, check the Enhancements reports every 4-8 weeks.
Conclusion: a schema test takes 5 minutes and saves you a lot of trouble
The schema test is not an optional step. It’s the difference between publishing structured data that works and publishing markup that no one will ever see. With three free tools and five minutes of your time, you can make sure Google reads what you intended it to read.
If you want to go deeper into how schema impacts your visibility, check out the article on Search Console and visibility in generative AI and the one on SEO, GEO and AEO. Schema is one of the strongest signals in all three channels.
Frequently asked questions
What is a schema test?
A schema test is the process of checking whether the structured data on your page is correct and valid. It tells you if Google can read your schema, whether it triggers rich results, and where there are errors or warnings to fix.
How do I run a schema test on my page?
You can use three free tools: Google’s Rich Results Test (to see if your page qualifies for rich results), the Schema.org validator (for a detailed structural check) and Google Search Console (to catch errors in indexed pages over time). Running all three gives you a complete picture.
What is the difference between the Rich Results Test and the Schema.org validator?
The Rich Results Test checks whether your structured data qualifies for rich results in Google Search and warns about missing recommended properties. The Schema.org validator checks the semantic and syntactic correctness of the markup itself, even if the type does not generate rich results.
What are the most common schema errors?
The most frequent errors are: missing required properties (such as image, author or datePublished in an Article), invalid date formats, incorrect nesting of types, URLs that return 404, and product or review schemas that do not match the visible content on the page.
How often should I run a schema test?
Every time you publish or update a page with structured data, and at least once a quarter to catch problems derived from changes in the site, the CMS, or the schema types that Google supports. In Search Console you can also monitor the Enhancements reports.
Want me to run a schema test on your site?
I’ll review your structured data, detect errors and give you an action plan with what to fix first.