Schema Markup Testing Tools in 2026: Which One to Use and When

The two schema markup testing tools that matter in 2026 are Google's Rich Results Test, which tells you whether a page is eligible for a Google rich result, and the Schema Markup Validator at validator.schema.org, which tells you whether your markup is valid Schema.org. Run the validator first, then the Rich Results Test. Google's old Structured Data Testing Tool is gone, even though many search results still point to it.

This guide covers what each tool checks, the order to use them in, and the problems none of them catch.

First, know what you're testing for

If you are new to structured data, it helps to first understand what JSON-LD actually is before comparing validators. "Is my schema valid?" is really two separate questions:

1. Is it valid Schema.org markup? Does it follow the Schema.org vocabulary and parse cleanly, with the required properties present and no syntax errors?

2. Is it eligible for a Google rich result? Does it meet Google's stricter, feature-specific requirements to earn an enhanced listing (review stars, recipe cards, product snippets, and so on)?

These are not the same test. Markup can be perfectly valid Schema.org and still be ineligible for any Google rich result, and Google supports rich results for only a subset of Schema.org types. Pick your tool based on which question you're asking.

The Schema Markup Validator (validator.schema.org)

The Schema Markup Validator checks whether your markup is valid Schema.org, for any type, whether or not Google shows a rich result for it. It is the general-purpose checker. Google migrated its old Structured Data Testing Tool to Schema.org back in April 2021, and it now lives at validator.schema.org as the Schema Markup Validator.

Use it when you want to confirm your markup is syntactically correct and follows the Schema.org vocabulary, for any schema type, not just the ones Google renders. It's the right first stop because it validates the foundation: nesting, required properties, JSON-LD syntax. Paste a URL or raw code and it parses the structured data it finds.

Reach for it when: you're building or debugging schema of any type and want a clean, vendor-neutral validity check.

Google's Rich Results Test (search.google.com/test/rich-results)

Google's Rich Results Test is Google's schema testing tool for one question: is this structured data eligible for a Google rich result, and how might it look? It tests against Google's rich-result criteria and previews the enhanced listing.

It's the authority on Google eligibility, but only for the features Google actually supports, and that list changes. Google has been trimming it: FAQ rich results, for example, stopped appearing on May 7, 2026, and Google said it would drop FAQ support from this test in June 2026. So a type not showing up here may simply mean Google no longer renders a rich result for it, not that your markup is broken.

Reach for it when: you're chasing a specific Google rich result (products, reviews, recipes, breadcrumbs, etc.) and need to confirm eligibility and preview it.

Bing and other validators

Bing Webmaster Tools has offered its own markup validator, useful if Bing traffic matters to you; check that it is still listed in your account before relying on it. There are also third-party viewers that render the parsed schema graph visually, which helps when you're untangling deeply nested markup. These are supporting tools, not replacements for the two above.

The recommended workflow

No single schema markup testing tool answers every question, which is why the sequence matters. The tools are complementary, so chain them:

1. Validate syntax first with the Schema Markup Validator. Fix any structural or vocabulary errors before worrying about rich results.

2. Then check Google eligibility with the Rich Results Test for any type you want an enhanced listing on.

3. Spot-check Bing if it's a meaningful channel for you.

Do it in that order. Testing rich-result eligibility on markup that isn't even valid Schema.org wastes time, fix the foundation, then test the feature.

What these tools cannot tell you

Both validators answer narrow questions. Passing them is necessary and nowhere near sufficient, and the gaps are where most real schema problems live.

Valid does not mean accurate. A validator checks that your markup is well formed, not that it describes the right thing. Product schema on a category listing page parses perfectly and is still wrong. So is an Article type on a service page, or a FAQPage wrapping questions nobody asked. The tool has no idea what your page is actually about, so it cannot flag the mismatch.

Markup has to match what a visitor sees. Google's structured data policies require the marked-up content to be present on the page. Prices, ratings and answers that live only in the JSON-LD and nowhere in the rendered page are a manual action risk, and no validator will warn you, because syntactically nothing is wrong.

You may be testing the wrong version of the page. If your schema is injected by JavaScript, the raw HTML and the rendered DOM disagree. Pasting source code into a validator tests markup Google may never use, and pasting a URL tests whichever version that tool chose to fetch. Confirm which one you are looking at before you trust a pass.

None of them tell you whether it worked. Eligibility is not a result. A page can sit eligible for a rich result for months and never receive one, because eligibility is permission rather than a promise. For that answer you need Search Console's rich result reports. Use a validator to prove the markup is sound, then watch Search Console to see whether Google acted on it.

Duplicate and conflicting blocks pass quietly. Two Organization blocks carrying different names, or several @id values pointing at the same entity in different ways, will each validate on their own while leaving a search engine to guess which one is true. Validators grade markup one block at a time, so contradictions between blocks slip straight through.

Where single-URL tools fall short

Our free Schema Markup Checker was built for exactly this gap. All of the above share one limit: they test one URL at a time. That's fine for building a template or debugging a single page. It's useless for the question that actually costs you traffic, is my schema still valid across the whole site?

Structured data breaks silently and at scale. A theme update, a plugin change, a migration, or a tweak to one template can invalidate markup on hundreds of pages at once, and no one notices until a rich result quietly disappears. You will not catch that by pasting URLs into a validator by hand.

That's the gap a site-wide crawler fills: it inventories every page's structured data, flags what's broken or missing, and lets you catch a template-level regression the day it happens instead of the month you finally check. The single-URL validators tell you a page is fine. A crawl tells you your site is fine.

Bottom line

Pick the schema markup testing tool that answers the question you actually have. Use the Schema Markup Validator for general validity, the Rich Results Test for Google eligibility, and a crawler to watch the whole site so a broken template doesn't erase your structured data behind your back. Match the tool to the question and you'll stop guessing whether your schema actually works.

CrawlTide checks structured data across every page it crawls and flags broken or missing schema before it costs you a listing, plus keyword, ranking, and AI-visibility tracking in one place. Start free at crawltide.com