Schema Markup Validator: How to Test Your Structured Data for Free

A schema markup validator tells you whether your structured data will work before Google does. It reads the JSON-LD, Microdata or RDFa on a page and reports broken syntax, misspelled schema.org properties and the required fields each rich result needs, with the line to fix. This guide covers how to validate schema markup for free, how it differs from the Google schema validator (the Rich Results Test), how to read a validator report, how to check an entire site instead of one page, and when to run the check again.

What is a schema markup validator?

A schema markup validator is a tool that checks structured data for syntax errors, unknown schema.org types and properties, wrong value types and missing required fields. You paste code or a URL and get an item-by-item report. Schema.org runs a free one, the Schema Markup Validator at validator.schema.org, and Google’s Rich Results Test then confirms rich-result eligibility.

You will see the same tool called a schema validator, a schema checker, a schema.org validator or a structured data tester. They all do the same job with different depth. A pure syntax checker only confirms the JSON parses. A vocabulary validator, such as validator.schema.org, also confirms every type and property exists in schema.org. A full schema markup validator adds Google’s rules on top, so you learn that your Product is valid schema.org but still cannot earn a rich result because it has no offer. Our free Schema Validator does all three in one pass, in the browser, with no account.

Try it now: paste your JSON-LD, or a whole page’s HTML, into the free schema validator below, or switch to Check a URL. It runs in your browser, needs no account, and reports errors, warnings and rich-result eligibility in one pass.

Google schema validator vs a schema markup validator

Google’s own schema validator is the Rich Results Test, which checks only the structured data that can earn Google rich results. Google moved its older Structured Data Testing Tool to Schema.org in 2021, where it became the Schema Markup Validator at validator.schema.org for general schema.org checks. Use both before publishing.

The two tools answer different questions, which is why you need both. A schema markup validator asks “is this correct?”: does the JSON parse, are the types and properties real, are the values the right kind, are Google’s required fields present. The Rich Results Test asks “will Google use it?”: it renders the live page as Googlebot, keeps only the types that have a rich result feature, and reports whether each is eligible. It stays silent about WebPage, Person, Service and anything else outside its gallery, and it does not explain a syntax error beyond the line number.

Run the schema markup validator while you are writing and fixing; run the Rich Results Test on the published URL as the final gate. The tool page has a side-by-side comparison of what each one checks.

How to validate schema markup for free

1. Generate the markup with a form instead of typing it. The Schema Markup Generator outputs valid JSON-LD for Article, Product, FAQ, LocalBusiness, Event and the other common types, and marks the fields Google requires as you fill it in.
2. Paste the block into the schema markup validator’s Code tab and press Validate. You get a summary strip (items found, errors, warnings) and one block per item. Fix every error, then re-run; a block with an error cannot be judged further until it parses.
3. Add the markup to the page through your SEO plugin’s schema settings, a Custom HTML block or your template, then purge the cache.
4. Switch to the URL tab and validate the live page. This fetches the HTML the way a crawler would and extracts every JSON-LD and Microdata block, so you catch duplicates from plugins, blocks that a cache or theme dropped, and markup you did not know the page had.
5. Finish in the Rich Results Test and, if the page is in Search Console, request indexing so the Enhancements report picks it up at the next crawl.

The whole loop takes about five minutes for a new template and under a minute for a routine re-check. You can bookmark a URL check for any page as softlearnhub.com/tools/schema-validator/?url= followed by the page address, which is handy for a template you test every release.

How to read the schema markup validator report

The report is built to be read top down. The summary strip tells you how many items were found and how many errors and warnings there are in total; if items is zero, the page has no readable structured data and the issues list will tell you why (usually a syntax error or a missing script type). Each item block is headed by its type, for example Article or Product, with a badge: Eligible when it has every required field and no errors anywhere inside it, Not eligible otherwise, and Valid schema.org for types Google has no rich result for but which are still correct.

Under each item the issues are graded. An error is a required property missing, a value of the wrong type, or an unknown type or property with no close match, and it blocks eligibility. A warning is a recommended property missing or a deprecated type such as HowTo, and the item stays eligible. An info line is a note with no action, for example that a nested Offer was checked as part of its Product rather than on its own. When a property name is misspelled, the message suggests the correct spelling (datepublished to datePublished), and every issue carries the path to the exact property, such as offers[0].priceCurrency, so you can find it in a long block without reading the whole thing.

What a good schema checker actually tests

• Syntax. Valid JSON with straight quotes, no trailing commas, no comments; a correct @context and an @type on every object, including nested ones.
• Vocabulary. Every type and property exists in schema.org, with case-sensitive spelling, and each property is allowed on the type it sits on. priceCurrency on an Article is as wrong as a misspelling.
• Value types. A Person or Organization where one is expected rather than a string; ISO 8601 dates and durations; absolute URLs; numbers for prices and ratings; schema.org enumeration URLs for availability and condition.
• Google’s required and recommended fields for each rich result type, taken from Google’s own documentation: offers, review or aggregateRating on a Product, startDate and location on an Event, position and name on each breadcrumb item, and so on.
• Nested items in context. An Offer is checked against Google’s Offer rules only when it sits inside a Product, because the same Offer under a Service has different expectations.
• Deprecated and retired types. HowTo rich results ended in September 2023 and FAQ rich results ended for all sites on 7 May 2026; the validator flags both as retired so you can decide whether the markup still earns its place.
• Duplicates. The same type declared twice on one page, which is how plugin and theme overlap shows up.

Common validation errors and quick fixes

One habit prevents most of these: never leave a property blank to “fill in later”. "image": "" is an invalid value, not a missing one, and it is harder to spot than an omission. Add the property when you have the data, then run the schema markup validator again.

Validating a whole site, not just one page

A schema markup validator checks one page at a time, and a site has thousands. The trick is that it does not have thousands of templates. Structured data on WordPress, Shopify and most other platforms is generated per template, so one post, one product page, one category page, one static page and the homepage usually cover every distinct block the site produces. Validate one URL per template after each release and you have validated the site.

For the long tail, two site-wide views fill the gap. Search Console’s Enhancements reports count valid, warning and error pages per rich result type across everything Google has crawled, and each error lists the affected URLs, which you can open straight into the validator. Desktop crawlers such as Screaming Frog can extract and validate structured data on every URL in one crawl, which is the right tool for a migration or a site with many hand-built pages. If you would rather hand this off, a structured data audit is part of the first review in our SEO and GEO service.

How often should you re-validate schema?

Not on a calendar. Re-validate when something that generates the markup changes, which in practice means:

• After any SEO plugin, theme or page builder update, because these own most of the markup.
• After editing a template or a Custom HTML block that contains JSON-LD.
• After a redesign or migration, when Microdata attributes in the old theme quietly disappear.
• When Search Console reports a new error or a rich result type’s valid count drops.
• When a rich result that used to show stops showing; test the live URL before assuming an algorithm change.
• Once a quarter as a sanity check if none of the above has happened, one URL per template.

What happens if you publish invalid schema

Nothing visible, which is the problem. The page renders normally, visitors see no error, and search engines simply ignore the block or the broken item inside it. You lose the rich result you were aiming for and the structured understanding that answer engines use when they decide which page to cite, but you do not get a ranking penalty for an honest mistake. The exception is markup that breaks Google’s structured data policies, for example a rating that is not on the page or FAQ markup for questions the page does not answer; that can earn a manual action that removes rich results across the site. No schema markup validator can see a policy problem, so the last check is always a human one: does the markup describe what a visitor actually sees?

A pre-publish checklist

• The block parses with zero errors in the schema markup validator’s Code tab.
• Every item Google has a rich result for shows Eligible; recommended fields are filled where you have real data.
• Every value in the markup is visible on the page, or is organisational data (logo, social profiles) that Google allows off-page.
• Dates, prices, URLs and enumerations use the machine formats, not the human ones.
• The live URL check finds exactly the items you expect, with no duplicates from a second plugin.
• The Rich Results Test on the live URL agrees, and the markup is present in its rendered HTML tab.
• Indexing requested in Search Console, and the Enhancements report checked after the next crawl.

Frequently Asked Questions

Is there a completely free way to validate schema markup?

Yes. Our schema markup validator, validator.schema.org and Google’s Rich Results Test are all free with no account or usage limit. Use the validator while you build, and the Rich Results Test on the live URL at the end.

Why does my schema pass schema.org but fail Google’s Rich Results Test?

Because schema.org makes almost every property optional while Google requires specific ones for each rich result. Valid vocabulary with a missing offer, image or date is correct schema.org and ineligible for Google at the same time. A validator that includes Google’s rules shows both verdicts.

Can invalid schema hurt my SEO rankings?

Not directly. Broken markup is ignored, so you lose the rich result but not your position. Markup that misrepresents the page, such as fake ratings, can lead to a manual action that removes rich results site-wide.

Do I need to validate schema every time I update a page?

Only when the change touches something the markup is built from: the template, a schema plugin setting, a Custom HTML block, the featured image or the publish date. Editing body text does not need a re-check unless the markup quotes it.

Does a schema validator check Microdata and RDFa as well as JSON-LD?

Our schema markup validator extracts JSON-LD and Microdata from a URL and reports RDFa when it is present; the Code tab accepts JSON-LD or a full HTML snippet. Google recommends JSON-LD for new markup, but all three formats are read.

The schema markup validator says eligible, so why is there no rich result?

Eligible means the markup clears the technical bar. Google still has to crawl and index the new version, judge the page worth the feature, and some features are restricted by site type or have been retired. Check URL Inspection for the last crawl date before changing anything.