Google vs Schema.org: Different Validator Purposes
In a Google SEO Office Hours, Google's Martin Splitt answered a question about structured data validation and how Google's validator can show different results than the Schema.org validator. Both Google and Schema.org offer tools for validating if structured data is correct, but they have fundamentally different purposes.
Rich Results Test vs Schema Markup Validator
Google's tool is called the Rich Results Test. Schema.org's tool is called the Schema Markup Validator. At first glance, one might think both structured data validators are validating by the same rules. But as Martin Splitt explained, that assumption doesn't hold up.
Google's Rich Results Test validates structured data and also offers feedback on whether the tested structured data qualifies for rich results in the search engine results pages. Rich results are enhanced search listings that make the listing stand out on the search results.
The Schema.org Schema Markup Validator checks if the structured data is valid according to the official standards. But here's the key distinction: Schema.org is an open and vendor-independent entity that defines the data types and attributes for structured data. Google, as a vendor, might have specific requirements for some attributes and types in order to use the structured data in product features, such as Google's rich results in Google Search.
Why Results Differ: Vendor-Specific Requirements
One would think that both structured data validators are validating by the same rules. So it's a good question as to why both validators may show different results.
The person asking the question noted that their structured data validated perfectly on Schema.org but not with Google's validator. They asked: "Why does structured data show errors on Google but not schema.org? Google Search Console is showing errors for invalid enum value in field 'returnFees' but our schema.org test says no error. Please advise."
Google's Martin Splitt answered:
"Schema.org is an open and vendor-independent entity that defines the data types and attributes for structured data. Google, as a vendor however, might have specific requirements for some attributes and types in order to use the structured data in product features, such as our rich results in Google Search. So while just leaving out some attributes or using some type of values for an attribute is fine with Schema.org, vendors such as Google and others might have more specific requirements in order to use the structured data you provide to actually enhance features and products."
When Schema.org Validates but Google Doesn't
The purpose of Google's validator is different from just checking if the structured data is valid. It's checking to see if the structured data that Google requires (for potentially showing a webpage in enhanced search results) is valid.
The Schema.org validator is just checking for standards and has nothing to do with how Google uses structured data. This means you can have structured data that is perfectly valid according to Schema.org standards but doesn't meet Google's additional requirements for rich result eligibility.
A concrete example from the original question: a publisher had structured data that passed the Schema.org Markup Validator with flying colors but triggered errors in Google Search Console. The specific error involved an invalid enum value in the 'returnFees' field. The Schema.org test said nothing was wrong, but Google's validator flagged it. This exact mismatch is why publishers sometimes look at both tools and see contradictory results.
Is Google's Validator Better?
One more thing to know about the Schema.org validator is that it can sometimes falsely report that valid code is invalid. I recently encountered this where I took a JSON-LD structured data example of correct code from Schema.org and tested it in both validators. The Schema.org validator showed a false error while Google's validator correctly validated it.
So at least in this case, Google's validator was more accurate. But that doesn't mean Google's validator is infallible. It simply means Google's validator reflects Google's specific requirements for its own search features.
What the Rich Results Test Actually Checks
The Rich Results Test has a dual purpose: it validates structural syntax while also assessing rich result eligibility. That dual function means it can flag issues that the Schema.org validator wouldn't catch — and vice versa. The Schema.org validator, by design, only checks against the open standard. It doesn't know or care about Google's feature-specific requirements, such as mandatory minimum properties, allowed value enums, or format constraints that Google imposes for a given rich result type.
Google's documentation reinforces this point. The Search Central structured data guide lists properties that Google considers required or recommended for each rich result type. If any of those are missing or misshapen, the Rich Results Test will surface an error — even though the same markup would sail through the Schema.org validator unchanged.
When Schema.org Validates but Google Doesn't (Expanded)
The publisher who asked the original question had every reason to be confused. Their markup was technically correct per the open standard, yet Google's tool rejected it. The culprit was often an enum value that Schema.org permits but Google restricts, or a property that Google expects in a particular format that the open standard leaves optional.
This mismatch is especially common with newer schema types or properties that Google has added conditions for without updating the broader Schema.org specification. In those cases, passing the Schema.org validator gives a false sense of security — the markup is "standard-compliant" but not "Google-compliant."
Is Google's Validator Better? (Deeper)
The question of which validator is "better" depends on your goal. If you want to know whether your markup meets open specifications, Schema.org's validator is the right check. If you want to know whether your markup will produce rich results in Google Search, Google's Rich Results Test is the definitive check.
In the example I ran personally, I took a JSON-LD snippet directly from Schema.org's own examples page and pasted it into both validators. The Schema.org validator returned an error for a property format issue. Google's Rich Results Test accepted it without complaint. That outcome aligns with Martin Splitt's explanation: Google's validator reflects what Google actually requires for its features, and sometimes those requirements are more lenient than the open standard.
But the reverse can happen too. The Schema.org validator has been known to flag syntax that Google accepts without issue, particularly around nested schema objects or properties that Google treats as optional even when Schema.org marks them as required. Neither validator is perfect, and neither should be treated as a silver bullet.
Best Practices for Structured Data Validation
Given the differences between the two tools, the safest approach is to use both — but in the right order and for the right purpose.
Start with the Schema.org validator to confirm your markup is structurally sound per the open standard. That catches syntax errors, missing required properties per the standard, and clear misuse of types or properties.
Then run the same markup through Google's Rich Results Test. Use the output to tune your implementation for Google's specific requirements: check for enum value constraints, optional but recommended properties that Google treats as mandatory for a given rich result type, and format quirks that Google's parser prefers.
And always, always consult Google's structured data documentation when implementing markup intended for Google Search. The Search Central guide is the authoritative source for what Google requires, and it's updated more frequently than the broader Schema.org specification.
The takeaway is blunt: don't assume that passing the Schema.org validator means your structured data will produce rich results in Google Search. The converse is also true — passing Google's test doesn't guarantee your markup is standard-compliant. Both validators have their place. Use the Schema.org validator to ensure your markup meets open standards. Use Google's Rich Results Test to ensure your markup meets Google's specific requirements for rich result eligibility.
Listen to the SEO Office Hours at the 4 minute mark:
Featured image by Shutterstock/ViDI Studio
Source: https://www.searchenginejournal.com/google-structured-data-validator/488772/
Roger Montti, June 8, 2023
