To check schema markup, run the page through Google's Rich Results Test to see whether it qualifies for a rich result, then the Schema Markup Validator to confirm the code against the full Schema.org vocabulary, and verify both in Search Console's Enhancements report. Passing one of these checks does not mean you pass all three, and that gap is exactly where most structured data quietly breaks.
Checking schema markup covers three distinct jobs that get lumped together as one: verifying the JSON-LD is syntactically valid, verifying it includes the properties a schema type needs, and verifying Google has actually read and rendered that markup on the live page. A page can pass the first two checks and still fail the third if a template breaks after deployment or a cache serves an old version. Most "why isn't my schema working" problems come from confusing these three jobs, so treat them as separate steps rather than one pass or fail test.
This matters because the tools available split along the same lines. No single tool checks all three at once, which is why a page can look fine in one report and broken in another. The rest of this guide walks through each tool in the order that catches problems earliest and cheapest.
Open Google's Rich Results Test, paste in a live URL or a raw code snippet, and run the test. Google fetches the page, or reads your pasted code, lists every structured data item it detected, and marks each one eligible, has warnings, or invalid, then shows a rough preview of any resulting rich result. It only reports on the schema types Google currently uses for rich results, so an item outside that list will not appear even if the code is valid.
The Rich Results Test replaced Google's original Structured Data Testing Tool, which was retired in 2020. Google split that tool's job in two: this one for rich result eligibility, and a separate validator, covered next, for general schema.org syntax.
The Schema Markup Validator, hosted at validator.schema.org, checks your markup against the entire Schema.org vocabulary rather than only the subset Google turns into rich results. It is the direct descendant of Google's original Structured Data Testing Tool, migrated to schema.org after Google retired its own general-purpose validator. Use it for schema types the Rich Results Test ignores, such as Person, SoftwareApplication, or a custom type you are still experimenting with.
In practice, run both when you are not sure which one applies. Paste the code into the Schema Markup Validator first for a straightforward syntax and vocabulary check, since it accepts more types and gives cleaner error messages for pure JSON problems. Then run the same URL through the Rich Results Test to see what Google specifically does with it. A type can be perfectly valid in the validator and still show nothing in the Rich Results Test, simply because Google does not build a rich result for that type at all.
Open Search Console, then the Enhancements section in the left-hand menu, to see every structured data type Google has found across your whole site, sampled and updated every few days. Each report lists valid items, items with warnings, and items with errors, and clicking through shows the exact URLs affected so you can fix a broken template once instead of checking pages one at a time.
Google marks issues with two levels of severity. A red error means a required rule is broken and the page is likely ineligible for that feature. A yellow warning means a recommended field is missing while the markup still works, which is worth fixing but will not block eligibility on its own. Because Enhancements data is sampled and can lag by days, use the URL Inspection tool right after a fix for an on-demand check of Google's current rendered version of one specific page, rather than waiting for the site-wide report to catch up.
Right-click the page and choose View Page Source, then search for application/ld+json, to see exactly what a non-JavaScript crawler receives on the first request. Inspect Element instead shows the live DOM after your browser has run every script, so it can display schema that was injected late, or hide markup a script accidentally removed. If a script tag appears in Inspect Element but not in View Page Source, that markup may be invisible to any crawler that does not execute your JavaScript.
This distinction trips up sites built with client-side frameworks more than plain HTML or WordPress sites, since a plugin that injects schema via JavaScript after the page loads can look perfect in the browser while shipping nothing in the raw response. For a faster look than digging through source code by hand, paste the same block into a checker like Rankite's free JSON-LD Schema Checker, which flags invalid syntax and the fields your declared @type expects, without needing devtools open at all.
Valid schema means the code parses correctly and matches Schema.org's structure. Eligible for rich results is a narrower, Google-specific bar: the object must include every property that specific feature requires, describe content genuinely visible on the page, and follow Google's content policies. Google's own documentation states plainly that you must include all required properties for an object to be eligible for appearance in Search with enhanced display, so valid but incomplete markup routinely fails this stricter second test.
Two real examples show the gap. First, Google tightened its review-snippet guidelines in late 2025 to bar self-serving reviews, meaning a business rating its own product with valid AggregateRating schema can still be ruled ineligible for star results, a policy check no validator performs. Second, Google removed FAQ rich results from Search entirely in May 2026; FAQPage markup can be flawless and still produce no expandable snippet, because Google stopped building that feature, not because anything is broken. Checking schema means confirming both the code and the current rules around it.
| Tool | What it confirms | What it misses |
|---|---|---|
| Rich Results Test | Google-specific eligibility for supported types, on one URL or snippet | Types Google does not surface, and policy issues like self-serving reviews |
| Schema Markup Validator | Syntax and structure against the full Schema.org vocabulary | Whether Google will actually build a rich result from it |
| Search Console Enhancements | Site-wide errors and warnings, sampled over time, with affected URLs | Fresh changes; data can lag by several days after a fix |
A 2026 audit of 5,000 production sites by Digital Applied found that 71% deploy at least one schema type, but only 22% pass Google's Rich Results Test cleanly across every type they emit, a 49-point gap between deploying schema and having it actually work.
The same audit traced over 90% of validation failures to five recurring patterns. Missing required properties, such as headline, datePublished, author, or offers, alone caused 38% of failures. Dates written in a human format like "April 26, 2026" instead of ISO-8601's "2026-04-26" caused another 24%, since Google's parser rejects them silently rather than flagging the page. The remaining share came from using the wrong @type for the actual page content, missing or invalid image dimensions, and duplicate @id values reused across multiple pages, which confuses the entity graph rather than describing separate things.
None of these five require rewriting your schema strategy. They require reading what the Rich Results Test or Search Console already told you and fixing the specific field it named, which is usually a two-minute edit once you know where to look.
Use this order whenever you add or change structured data, so cheap checks catch problems before slower ones do.
If you are auditing schema across a whole site rather than one page, our technical SEO audit checklist covers where structured data fits alongside crawl budget, indexation, and Core Web Vitals. And if the goal is AI citations specifically, not just Google rich results, our breakdown of structured data for AI search ranks which schema types are worth checking first.
Check schema markup immediately after any template change, CMS migration, or SEO plugin update, since those three events cause most breakage. Outside of that, a monthly or quarterly look at Search Console's Enhancements report for your most important pages is enough to catch drift before it costs you a full reporting cycle of lost rich results. Sites that publish frequently, or that run several plugins touching the same templates, should lean toward monthly rather than quarterly.
What does it mean to check schema markup? Checking schema markup means confirming three separate things: that the code is valid JSON-LD, that it includes the fields Schema.org and Google expect for that type, and that Google has actually read it correctly on the live page. Passing one check does not guarantee the other two.
What is the fastest way to check schema markup? Paste the JSON-LD block into a free checker like Rankite's JSON-LD Schema Checker to catch syntax errors and missing fields in seconds. For a live page, run the URL through Google's Rich Results Test, which takes under a minute and shows exactly what Google detected.
How is the Schema Markup Validator different from the Rich Results Test? The Rich Results Test is Google's own tool and only checks the schema types Google actually turns into rich results. The Schema Markup Validator, hosted at validator.schema.org, checks any schema.org type against the full vocabulary, including types Google does not surface as rich results at all.
Is the Rich Results Test the same as the old Structured Data Testing Tool? No, though it replaced it. Google retired the original Structured Data Testing Tool in 2020 and split its job in two: the Rich Results Test for Google eligibility, and the Schema Markup Validator, migrated to schema.org, for general syntax and vocabulary checks.
Why does my schema pass validation but still not show a rich result? Valid code and rich result eligibility are different things. Google's own documentation states an object needs every required property for its specific feature to be eligible, and a page can also lose eligibility for policy reasons, like self-serving reviews, that no validator checks. Some types, including FAQPage, no longer produce a rich result in Google Search at all as of 2026, even when the markup is flawless.
How do I check if schema markup is actually in my page's HTML, not just injected by JavaScript? Use your browser's View Page Source, not Inspect Element, to see the raw HTML a crawler receives on first load. Inspect Element shows the live DOM after your browser runs every script, so it can display schema that was injected late or hide markup a script accidentally removed. If a script tag appears in Inspect Element but not View Source, a crawler that skips JavaScript rendering may miss it.
How do I check schema markup in Google Search Console? Open the Enhancements section of Search Console for a sampled, site-wide view of every structured data type Google has found, with valid items, warnings, and errors listed separately. Use the URL Inspection tool for a one-off check that confirms whether Google's own render of a specific page includes the schema you expect.
What is the most common schema markup error? A 2026 audit of 5,000 production sites by Digital Applied found that missing required properties, such as a headline, author, or offers, caused 38% of validation failures, the single largest error category. Wrong date formats and using the wrong @type for the page's actual content were the next most common issues.
Does valid schema markup guarantee better rankings? No. Google has said structured data is not a general ranking factor. It helps engines understand and, for supported types, display your content, but strong content and authority still do the ranking. Checking schema protects distinctions and eligibility you have already earned rather than manufacturing new ones.
How often should I check schema markup? Check it whenever you change a template, migrate a CMS, or update an SEO plugin, since those are when schema quietly breaks. Beyond that, a quarterly spot check of your top pages in Search Console's Enhancements report catches drift before it costs you a full quarter of rich results.
Pick one page, run it through the Rich Results Test, and read what it actually flags before touching anything else. If the markup is missing entirely, start with our guide to adding schema markup in WordPress. If it exists but keeps failing, request a free SEO audit from Rankite and we will show you which structured data is costing you rich results and AI citations.
Get a free, no-obligation SEO audit and a 30-minute strategy session. We'll show you exactly where the growth is hiding.
Fill out the form and we'll get back to you within one business day. Prefer email? Write to us directly at contact@rankite.com.
