Schema Validator Online — Free Schema Validator Tool

CodexFuse Team · 2026-11-05T11:56:01.944Z · 11 min read min read

Free schema validator: paste your JSON-LD markup and get a 0-100 score in seconds, with four named checks — valid JSON, @context, @type and content fields.

A schema validator is a free online tool that checks the JSON-LD structured data on your website and tells you, in seconds, whether search engines can actually read it. You paste your markup, it runs four checks — valid JSON, @context, @type and content fields — and returns a score out of 100. If your pages carry broken or half-finished schema, Google simply ignores it, and the rich results you were hoping for never appear.

That silent failure is the real problem. Most small business owners add schema once and never check it again, assuming it works because the page still loads. A browser does not care about your JSON-LD. Google does — and one missing comma or forgotten @context is enough for the whole block to be skipped without a word.

What does a schema validator actually check?

A schema validator checks four things in pasted JSON-LD markup: whether the text is valid JSON, whether it declares a @context (usually https://schema.org), whether it declares a @type, and whether it contains at least three content fields such as name, description or price. Each check passes or fails by name, and the score is passed checks out of four, times 25 — so four out of four is 100, three out of four is 75, and two out of four is 50.

Each check catches a different mistake. Valid JSON is the gatekeeper: unparseable text stops the tool with an "Invalid JSON" message and no score. The @context names the vocabulary — without it, terms like "Product" have no defined meaning. The @type says what the thing is. The content fields are the facts a rich result would display. Grades run GOOD at 75 and above, FAIR from 50 to 74, and POOR below 50 — but a 75 can still be thin, so aim for 100.

Why broken schema quietly costs you rich results

Rich results are the extras Google can show next to your listing: star ratings, prices, stock status, FAQ dropdowns. They take up more space and answer the searcher's question before the click, so pages that earn them typically see higher click-through rates than plain links on the same query. None of that is available to a page whose schema is broken, because Google will not render what it cannot parse.

The cost is quiet because nothing visibly breaks. Your site loads, orders still come in — you simply never appear with the enhanced listing your competitor does. Validation is the cheapest check against that drift: under a minute, free, and it turns an invisible problem into four named pass-or-fail lines.

How to use a schema validator in under a minute

First, get the markup out of your page: view its source and copy the JSON-LD block — the script tag with type "application/ld+json". Do not retype it from memory; retyping introduces exactly the typos you are trying to catch.

Then open the schema validator tool, paste the block into the box, and click Validate Schema. The tool opens on a WebPage example that scores 100, so you can see a passing result before pasting your own. Within a second you get the 0–100 score, the GOOD / FAIR / POOR grade, and each check listed as passed or failed. Fix the failed check, paste again, and validate until the score reads 100. A copy button takes the result with you in one click, and everything runs in your browser — nothing you paste leaves your machine. One honest note: the page asks you to log in, or create a free account, before using it. That is a one-time step; validation itself is then instant.

A worked example: fixing a bakery's Product schema

Meera runs a two-person bakery in Leeds, Crumb & Craft Bakery, selling a Sourdough Gift Box for £24. Her developer added Product schema to the gift box page six months ago, expecting the price and a star rating to show in search results. They never did, and nobody investigated — the page looked fine, and orders still came in.

Meera copied the JSON-LD block from the live page and pasted it into the validator. The result was 50, graded FAIR. Valid JSON passed and @type passed (Product), but @context failed — her developer had copied only the inner object and left the "@context": "https://schema.org" line behind — and the content-fields check failed too, because the block carried only two fields, name and price.

The fix took four minutes: add the @context line, then add three fields the Product type genuinely needs — a one-line description, the availability status, and the bakery's aggregate rating of 4.8 from 63 reviews. She pasted again: four out of four checks passed, score 100, grade GOOD.

The tool found in seconds a problem that had cost Meera six months of invisible rich results. But a 100 means the markup is structurally sound — it does not force Google to show a rich result, which is a separate decision per query. Her next step was Google's Rich Results Test, and validation went on her publishing checklist so no future product page ships unchecked.

The schema errors a validator catches most often

The same handful of mistakes appears on small business sites again and again. Each is a one-line fix once the tool names it.

• Missing @context: the most common failure. The inner object gets copied without its opening lines, and the markup becomes meaningless to a parser. Copy the whole script block, opening brace to closing brace.
• Trailing commas and single quotes: JSON is strict. A comma after the last item, or single quotes where double quotes belong, invalidates the whole block — fix the JSON first, then validate the structure.
• A @type with no content fields: declaring "Product" and then giving no name, price or description. The three-field minimum catches this, but include every field the type genuinely needs.
• Wrong @type for the page: Article markup on a product page, or Product markup on a blog post. The check confirms the type exists; matching it to the page is your job.
• Copy-paste truncation: long blocks clipped by an editor or a CMS field. If the tool reports invalid JSON on markup that "looked fine", count the braces — one is usually missing at the end.

What validation cannot tell you

Honest limits matter, because a green score can create false confidence. The tool checks structure, not truth: it cannot tell whether your price is correct, your rating is real, or your opening hours match your door. If the facts inside the markup are wrong, it will still score 100. It also does not check a JSON document against a JSON Schema file — that is a different job, handled by a dedicated JSON Schema tool — and it cannot fetch a live URL, so the copy-from-source step is on you.

Most importantly, a 100 does not guarantee rich results. Google decides eligibility, relevance and quality per query, and markup that contradicts the visible page content can be ignored or penalised. Treat validation as the entry ticket — necessary, fast and cheap — not the prize itself.

Where validation fits in a managed workflow

Validation earns its keep when it becomes a habit rather than a one-off rescue. Put it on the publishing checklist for every page that carries schema: product pages, articles, local business pages, recipes, reviews. The check takes less than a minute, and it is far cheaper than discovering six months later that a rich result never appeared.

That habit is easier to keep when the rest of the site is not demanding your attention. On CodexFuse, the site lives on fully managed hosting: server, security patching and backups handled for you, paid with credits as you use services — no monthly subscription, no lock-in. Move the site to CodexFuse hosting, top up credits in whatever amount suits you, and spend the time you used to spend babysitting a server on the work that earns clicks. Add business email on the same platform so order confirmations come from your own domain. The rule is simple: if you would rather check schema than check server logs, a managed platform is the right fit.

For richer markup once validation is routine, generate schema for the content types you publish most. A business details schema tells Google who you are, a review schema carries your ratings, and an article schema marks up every blog post. To create markup first, a schema markup generator writes the JSON-LD block for you from a type, a name, a URL and a description.

Frequently Asked Questions

What does a schema validator check?

Four things in pasted JSON-LD markup: valid JSON, a @context, a @type, and at least three content fields. Each check passes or fails by name, and the score is passed checks out of four, times 25.

What score should my schema get?

Aim for 100, graded GOOD. Grades are GOOD at 75 and above, FAIR from 50 to 74, and POOR below 50. A 75 is technically GOOD but thin, so add the fields the type needs before publishing.

Can a schema validator check a live page?

No. It only checks markup you paste in and never fetches a URL. View the page source, copy the JSON-LD block inside the script tag with type "application/ld+json", and paste it into the tool.

Does a score of 100 guarantee rich results?

No. A 100 means the markup is structurally valid and complete, which is necessary but not sufficient. Google decides separately whether a page is eligible, and markup that contradicts the visible page content can be ignored.

Is the CodexFuse schema validator free?

Yes. It is free and instant, runs entirely in your browser, and scores pasted JSON-LD out of 100 with four named checks. The page asks you to log in or create a free account first, and the example markup it opens with scores a full 100.

What is the difference between this tool and a JSON Schema checker?

They do different jobs. This tool checks pasted JSON-LD schema.org markup itself — its structure and the presence of @context, @type and content fields. A JSON Schema checker compares a JSON document against a schema file to confirm it conforms.

Validate your schema, then put the whole site on managed rails

Open the validator now and paste in the JSON-LD from your most important page — your homepage, your best-selling product, your top blog post. If it scores below 100, fix the named checks and validate again until it reads GOOD. Then do the same for every page that carries schema, and add the one-minute check to your publishing list.

And while you are fixing what Google sees, fix what runs underneath it. Move your hosting, business email, security and backups to CodexFuse today: one fully managed platform, pay-as-you-go credits, no subscriptions and no server babysitting. Your next rich result starts with valid schema — and your next quiet failure ends when someone else is watching the server for you.