CrawlCheck

Guides · 2026-10-03 · By · 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.

Check your own site free

About a minute. First scan free with your email, nothing installed.

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 TestSchema Markup Validator (validator.schema.org)CrawlCheck
Question it answersWhich Google rich results this markup can produceIs this valid schema.org markupDoes this markup describe one resolvable entity
ScopeOnly types Google supports for rich resultsAll 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 webNoNoYes: schema name, address and phone against the visible page; each sameAs profile checked for a link back
Finds duplicate or colliding entitiesNoNoYes: two unlinked organisation nodes (the same @id parsed twice is correctly one entity)
Tests a pasted snippet before publishingYesYesNo: reads only what is live
PriceFreeFreeFirst 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:

ProblemShare of scanned sites
Two organisation nodes that do not link to each other (an entity collision)2.6%
A business entity with no coordinates6.2%
Directory listings the site does not declare3.6%
Business name drifting between schema and page0.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:

QuestionResult 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.

1. Does it parse?JSON syntax2. Valid and eligible?vocabulary, Google rules3. Matches the page?name, phone, address4. Matches reality?the real business recordRich Results Test and Schema Markup ValidatorCrawlCheck (step 3), then you (step 4)
Each step answers a different question. Passing one says nothing about the next.

A five-step check, in order #

  1. Rich Results Test on the live URL. Confirms the markup Google features parses and shows which rich results it can produce.
  2. Schema Markup Validator for everything else. Types Google does not feature (a Service, a Person, a DefinedTerm) are still read by other systems.
  3. 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.
  4. 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.
  5. A CrawlCheck scan for coherence. One entity per business, coordinates on the business node, and sameAs profiles that link back to the site.

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 of scanned sites with each finding in this articleAddress with no coordinates6.2%Directory listing the site does not link3.6%Two business records share a phone, @id or location2.6%Directory listing under a different name0.6%Share of scanned sites with eachfinding in this articleAddress with no coordinates6.2%Directory listing the site does not link3.6%Two business records share a phone, @id or location2.6%Directory listing under a different name0.6%
Read live from the same counters the dataset page uses, at the moment this page was served. Bars are scaled to the largest value shown, not to 100%.

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.

Submit an article

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.

All guides · The dataset · How the dataset works