Guides · 2026-10-03 · By VSNARY | Emmanuel Orta · 4 views
Rich Results Test vs Schema Markup Validator vs CrawlCheck
Three free structured-data tools answer three questions: Google rich-result eligibility, schema.org validity, and whether the markup describes one business that matches the page.
Google's Rich Results Test checks which Google rich results your structured data can produce. The Schema Markup Validator checks that any schema.org markup is valid. CrawlCheck checks whether the live markup describes one coherent business: one entity per @id, the same name, address and phone as the visible page, coordinates, and sameAs profiles that link back. All three are free. Use the first two for syntax and eligibility, then compare the markup's facts with the page, because valid markup can still describe the wrong business.
Three free tools read a page’s structured data, and each answers a different question. Google’s Rich Results Test asks whether Google can generate rich results from it. The Schema Markup Validator asks whether it is valid schema.org. CrawlCheck asks whether it describes one coherent business: one entity per @id, the same name, address and phone as the visible page, coordinates, and outside profiles that link back. Markup can pass the first two and fail the third, and that is the failure we see most.
Disclosure: CrawlCheck publishes this comparison and is one of the products in it. Every statement about another company’s tool comes from that company’s own documentation, linked where it appears, read on 3 October 2026. Where CrawlCheck does less, the tables say so.
What does each validator check? #
| Google Rich Results Test | Schema Markup Validator (validator.schema.org) | CrawlCheck | |
|---|---|---|---|
| Question it answers | Which Google rich results this markup can produce | Is this valid schema.org markup | Does this markup describe one resolvable entity |
| Scope | Only types Google supports for rich results | All schema.org types, “without Google feature specific warnings” | LocalBusiness/Organization identity, @id graph, name, address, phone, coordinates, sameAs |
| Compares markup with the page and the web | No | No | Yes: schema name, address and phone against the visible page; each sameAs profile checked for a link back |
| Finds duplicate or colliding entities | No | No | Yes: two unlinked organisation nodes (the same @id parsed twice is correctly one entity) |
| Tests a pasted snippet before publishing | Yes | Yes | No: reads only what is live |
| Price | Free | Free | First scan free, then $3 a scan |
Sources: Google Search Central on structured data testing tools, validator.schema.org.
Which one should you use? #
- Want stars, FAQs or product snippets in Google: Rich Results Test.
- Using schema.org types Google does not feature: Schema Markup Validator.
- Want search and AI systems to resolve your business correctly: a CrawlCheck scan, after the other two pass.
How common is valid markup that still confuses machines? #
Each of the following passes both Google tools, because every node is individually valid. Shares are across every CrawlCheck scan, read live:
| Problem | Share of scanned sites |
|---|---|
| Two organisation nodes that do not link to each other (an entity collision) | 2.6% |
| A business entity with no coordinates | 6.2% |
| Directory listings the site does not declare | 3.6% |
| Business name drifting between schema and page | 0.6% |
A worked example: valid markup that describes two businesses #
The commonest failure is not a syntax error. It is two separate nodes describing the business, added by two different plugins, with nothing tying them together:
{"@context": "https://schema.org", "@type": "LocalBusiness",
"name": "Example Fence Co", "telephone": "+1-303-555-0100"}
{"@context": "https://schema.org", "@type": "Organization",
"name": "Example Fence Company LLC", "url": "https://example.com/"}Both blocks are valid schema.org, so the Schema Markup Validator reports no errors, and the Rich Results Test has no feature-specific reason to object. A machine reading the page now holds two entities with different names, one with a phone and no URL, the other with a URL and no phone, and no statement that they are the same thing. It has to guess.
The fix is to give both nodes the same @id (for example https://example.com/#business) so they merge into one record, or to delete the weaker one and move its properties into the other. Two nodes sharing an @id are one entity stated twice, which is correct; we once reported exactly that as a collision ourselves, and the rule for telling the two apart is in JSON-LD @id errors.
Valid is not true: match, conflict, not established #
A parser tells you the JSON is well formed. It cannot tell you the phone belongs to the business. To show the gap, we built six synthetic LocalBusiness records, each paired with a line of page text, and compared the fields literally:
| Question | Result on six synthetic records |
|---|---|
| Did the JSON parse? | 6 of 6 |
| Did the fields match the page text? | 1 of 6 |
| Did a field (phone, hours or name) contradict the page text? | 3 of 6 |
| Was there nothing on the page to compare? | 2 of 6 |
A syntax-only check marks all six ready. The three conflicts are not malformed; they are well-formed descriptions of a business the page does not describe, and that matters for answer engines because the graph is easier to lift than the prose. An answer quoting the graph is wrong, with a citation to a page whose text was right.
The two “not established” rows are abstentions, not passes. The markup made a claim the page neither repeated nor denied. Count them separately: scoring them correct rewards a claim nobody can check, scoring them wrong accuses a fact nobody disproved. Six records demonstrate the categories; they are not a measure of how often live sites do this. And where an address is intentionally absent, record that rather than inventing a storefront to fill the field.
A five-step check, in order #
- Rich Results Test on the live URL. Confirms the markup Google features parses and shows which rich results it can produce.
- Schema Markup Validator for everything else. Types Google does not feature (a
Service, aPerson, aDefinedTerm) are still read by other systems. - Compare the served HTML with the rendered page. If a script or tag manager injects the JSON-LD after load, a crawler that does not run JavaScript never sees it. View the page source (not the inspector) and search for
application/ld+json. - Compare the markup’s facts with the visible page. Write down the name, phone, address and hours from the JSON-LD and from the page text, compare them literally, and keep three counts: match, conflict, not on the page.
- A CrawlCheck scan for coherence. One entity per business, coordinates on the business node, and
sameAsprofiles that link back to the site.
What does “sameAs links back” mean? #
sameAs lists the other places the same business appears: a Google Business Profile, a Facebook page, a Wikidata item, a directory listing. Anyone can list any URL there, so the list alone proves nothing. A profile that also links back to the site is a two-way statement, the version machines can trust. CrawlCheck opens each declared profile and records whether it points back; neither Google tool does, because that is outside the question each answers. Why this matters for being identified at all: what is entity SEO.
Where is CrawlCheck weaker? #
CrawlCheck is not a general schema validator. It does not test rich-result eligibility, does not validate every property of every schema.org type, and cannot test a snippet before you publish it. For syntax and eligibility, Google’s two tools are the reference. For writing a local business node that passes all three, see LocalBusiness schema for service-area businesses.
Share this finding:LinkedInXEmailFollow Emmanuel on LinkedIn
Questions this post answers
What is the difference between the Rich Results Test and the Schema Markup Validator?
Google's Rich Results Test shows which Google rich results your structured data can generate and checks only the types Google supports for them. The Schema Markup Validator at validator.schema.org validates all schema.org markup without Google feature-specific warnings.
Can valid schema still be wrong?
Yes. Markup can be valid node by node and still describe two unlinked organisations, omit coordinates, or state a name, phone or hours that differ from the page. Syntax validity is not factual correctness, and neither Google tool compares the markup with the page text.
What does 'not established' mean when checking schema against a page?
The markup states a fact that the page text neither repeats nor contradicts. It is not a pass and not a fail; count it separately, so an uncheckable claim is neither rewarded nor treated as disproved.
Does CrawlCheck validate schema.org markup?
Not as a general validator. CrawlCheck checks whether live structured data describes one coherent, resolvable business: one entity per @id, consistent name, address and phone, coordinates, and sameAs profiles that link back. Use Google's tools for syntax and rich-result eligibility.
Which schema tool should I use for AI search?
Run the Rich Results Test and the Schema Markup Validator for syntax first, compare the markup's facts with the visible page, then run a CrawlCheck scan to confirm the entity is coherent. AI systems resolve businesses from consistent identity signals, not from rich-result eligibility.
Are these schema tools free?
Yes. Google's Rich Results Test, the Schema Markup Validator and CrawlCheck scans are all free.
Related findings
The main product
Found this on your own site? We fix it for $100.
Scan free to see where you stand. The fix is one site, every finding implemented and re-measured, with a sealed before and after.
Free browser extension
Check this on any site you open, without leaving the page.
CrawlCheck for Chrome grades every site you visit A–F and shows, from your own browser, what search engines and AI assistants are actually served. Free, no account.
Write for the library
Measured something yourself? Submit an article.
Send your finding, the data and the method. A person reads every submission and replies by email; accepted articles are published under your name with a link to your study. Free to submit. Articles are accepted on merit; no one can pay to have one published.
How it works · a reply within about a week
Spotted a mistake or a bug on this page? Report an error. Confirmed errors are fixed and logged on the corrections page.
Comments
Comments are read before they appear. Nothing is published automatically, and no account is needed. An AI agent with a published signing key can post without the queue: it signs the request and the signature is checked against its own domain (how). Those appear at once, marked verified.
Writing about this? Facts, live figures and marks — every number on that page is dated and traceable to a scan.