- Step by step: test a page with the Rich Results Test
- Errors, warnings and 'valid' explained
- When to use the Schema Markup Validator
- Which format to test: JSON-LD, Microdata or RDFa
- The mistakes that cost rich results
- Testing a whole site, not just one page
- Monitor after you publish
- My verdict
- Frequently asked questions
To test schema markup, paste the page URL or the code into Google's Rich Results Test to see which rich result types Google can read and any errors, then run it through the Schema Markup Validator to check the schema.org vocabulary itself. After publishing, watch the rich result reports in Search Console, because a clean test doesn't guarantee Google will show a rich result.
Those are two different questions. The Rich Results Test asks 'can this page get a Google rich result?' The Schema Markup Validator asks 'is this valid schema.org?' Markup can pass the second and still earn nothing from the first, because Google supports only some types and has its own required properties.
Step by step: test a page with the Rich Results Test
- Open the Rich Results Test and choose URL or Code.
- For a live page, paste the full URL. Google says every resource must be reachable by an anonymous visitor, so pages behind a login or firewall can't be tested by URL.
- For a draft, choose Code and paste the HTML or JSON-LD. You can edit it and rerun the test as often as you like.
- Pick the user agent. The default is smartphone, and you can switch to desktop.
- Read the results: which rich result types were found, plus any errors or warnings. Click an item to open the code explorer at the line that caused it.
- Fix errors first, rerun, then publish.
One trap from Google's help page: the test ignores comments inside JSON-LD, but the JSON-LD standard doesn't support them, so they can break the markup in real use. Strip comments out before you publish.
Errors, warnings and 'valid' explained
| Result | What it means | What to do |
|---|---|---|
| Error | A required property is missing or broken, so the item isn't eligible for that rich result | Fix before publishing |
| Warning | A recommended property is missing; the item can still be eligible | Add it if you have the real information |
| Valid items detected | Google can read the markup for that feature | Publish, then monitor in Search Console |
| Crawl failed or page not crawlable | Google couldn't fetch the page (for example blocked by robots.txt) | Fix access first, then retest |
On warnings, Google's own advice is to give fewer but complete and accurate recommended properties, rather than trying to fill every possible one.
When to use the Schema Markup Validator
Use it for schema.org types Google doesn't turn into rich results, such as Organization details or types you add for other platforms and AI tools. It checks the vocabulary and structure. It won't tell you whether Google will show anything special.
Which format to test: JSON-LD, Microdata or RDFa
The Rich Results Test supports all three. Google says all three formats are equally fine as long as the markup is valid, and it recommends JSON-LD in most cases because it's easiest to implement and maintain. Google can also read JSON-LD that's added dynamically, which matters if a plugin or tag manager injects it.
The mistakes that cost rich results
Passing the test isn't the end. Google's general structured data guidelines list the problems that can lead to a manual action, which removes a page's eligibility for rich results:
- Marking up content that visitors can't see on the page.
- Irrelevant or misleading markup, such as fake reviews.
- Markup that doesn't match what the page is about.
Google also says plainly that it doesn't guarantee structured data will show up in results, even when everything is correct. If a rich result never appears, check the page's quality and relevance before you blame the code. To check for a manual action, open the Manual Actions report in Search Console.
Testing a whole site, not just one page
The Rich Results Test checks one URL at a time, which is fine for a new template but slow for a big site. The smart way is to test one example of every template you use: a blog post, a product page, a category page, an FAQ page, a location page. Most sites have only a handful of templates, and the markup on each one is generated the same way across every page that uses it. If the example passes, the rest usually will too.
Then retest the same examples whenever you change your theme, swap an SEO plugin or add a new tag manager script. Those are the moments markup breaks quietly. A site crawler that extracts structured data can help you spot pages where the markup has gone missing altogether.
Want AI doing the heavy lifting in your marketing?
I build the systems that handle the boring 80 percent, so you get your week back. Done properly, with the human kept in.
Monitor after you publish
Search Console has rich result status reports for the supported types it finds on your site. Check them a week or two after publishing and after any theme or plugin change, since a template update can break markup across hundreds of pages at once.
If you're generating markup rather than writing it by hand, my roundup of schema markup generators compares the options, and for local businesses there's a ready-made service-area schema cheat sheet. Full SEO suites can also flag broken structured data during a crawl; I've compared them in Semrush alternatives.
My verdict
Test every new template in the Rich Results Test before it goes live, use the Schema Markup Validator for anything Google doesn't display, and only mark up what's visible on the page. Then let Search Console tell you what Google picked up. Clean code is the entry ticket, not the prize.
Frequently asked questions
What's the best way to test schema markup?
Use Google's Rich Results Test to see which rich results Google can read, and the Schema Markup Validator to check the schema.org vocabulary. Then monitor Search Console's rich result reports.
Can I test schema before a page is live?
Yes. In the Rich Results Test, choose Code and paste your HTML or JSON-LD. You can edit and rerun it as often as you like.
Why isn't my rich result showing even though the test passes?
Google says it doesn't guarantee structured data will show in results. Eligibility is only the start; quality and relevance also count.
Is JSON-LD better than Microdata?
Google says all three formats are equally fine if the markup is valid, and recommends JSON-LD in most cases because it's easiest to maintain.
What's the difference between an error and a warning?
An error means a required property is missing or broken, so the item isn't eligible. A warning means a recommended property is missing, but the item can still be eligible.
