Schema Tool

Summary#

Schema Tool fetches a live URL, pulls out every JSON-LD block, microdata item and RDFa type on the page, validates each one against schema.org's required and recommended properties, and shows you a preview of the rich result the page qualifies for. It costs nothing.

Purpose#

Structured data is how you tell a search engine what a page is rather than what it says. It is also the difference between a plain blue link and a result with a star rating, a price, a recipe time or an expanded FAQ. Those enhanced results take up more space and earn more clicks at the same ranking position.

The problem is that structured data fails silently. A missing comma makes a block invalid and Google ignores it entirely, with no warning anywhere. A missing required property makes the block ineligible for the rich result you added it for. Nothing on the page looks wrong.

This tool exists to make those silent failures loud. The decision it helps you make is what to add or fix so this page can win an enhanced search result.

Overview#

You give it a URL. Metric Vault fetches the page with a normal browser user-agent — many sites reject bot requests, which used to make pages look empty — and falls back to a Googlebot user-agent if that fails.

From the returned HTML it extracts three kinds of structured data: JSON-LD <script> blocks, microdata (itemscope / itemtype) and RDFa (typeof / vocab). Each JSON-LD block is parsed as JSON, and every @type inside it is collected recursively — through @graph containers, arrays and nested objects, so a type buried three levels deep is still found.

Each node is then validated against a rule table covering 20 common schema types. A missing required property is an error; a missing recommended property is a warning. And if a page has no structured data at all but is clearly built with a JavaScript framework, the tool says so instead of pretending the page is empty.

Benefits#

• Finds every type, however nested. @graph, arrays and nested objects are all walked.
• Real validation, not just detection. Required and recommended properties are checked per type.
• Honest about what it cannot see. A blocked fetch and a JavaScript-rendered page are reported as themselves, never as "no schema".
• Shows the payoff. A Google search preview per detected rich-result type.
• Free on every plan, with the raw JSON of each block available to copy.

Use Cases#

• Before publishing a product or article page. Confirm the block you added parses and carries every required property.
• Chasing rich results you are not getting. The page has FAQ markup but no FAQ result; this tells you which required property is missing.
• After a CMS or plugin update. Schema plugins change output silently, and invalid JSON is one deploy away.
• Copying what works. Run it on a competitor's page that has star ratings in the results and see exactly which types and properties they use.
• Auditing a template. One product page tells you about every product page.

Requirements#

• A signed-in Metric Vault account.
• Any plan, including Free.
• A publicly reachable URL. Private, internal and loopback hosts are refused.
• No credits, no integration, no ownership check.

Permissions#

No role restriction applies. See Roles and what each can do.

Cost#

0 credits. The button reads Validate Schema · FREE. The run never touches your monthly credit allowance and counts only toward the fair-use limit of 100 light-tool calls per hour. See How credits work and What you get on Free.

There is no result cache and no "You already ran this" prompt — every run fetches the page again, so you can validate a fix the moment you deploy it.

Navigation Path#

Dashboard → Site Health → Schema Tool

Inputs#

Step-by-Step Guide#

1. Open Dashboard → Site Health → Schema Tool.
2. Optionally click See example for a free preview of the report.
3. Paste the page URL into the field marked e.g. https://nike.com/product.
4. Click Validate Schema · FREE, or press Enter.
5. Read the Structured-Data Verdict, then Key Findings.
6. Work down Recommended Next Steps, which names each missing property explicitly.
7. Open All JSON-LD Blocks to see the raw markup of any block that failed.
8. Export from the row at the top of the screen: Export PDF, Export Excel, Export CSV, Export JSON or Share public link.

Reading the Results#

The KPI tiles.

Structured-Data Verdict. One of four headlines, with a sentence naming the counts and the types found:

• No structured data found — zero JSON-LD blocks. Rich-result eligibility is lost entirely.
• Invalid JSON-LD detected — at least one block failed to parse. Google ignores invalid blocks completely, so this is as bad as having none.
• Rich structured data — three or more types detected, all valid.
• Basic structured data — valid markup, but only one or two types.

Key Findings. The specific observations, tone-coded. The ones that matter most:

• "No JSON-LD blocks. Search engines fall back to weaker signals; rich-result eligibility is lost."
• "*N* block(s) contain invalid JSON — Google ignores them entirely."
• "No high-value primary types (Article/Product/LocalBusiness/FAQ/HowTo etc.). Rich snippets unlikely."
• "Primary type(s) present: X — eligible for rich results."
• "*N* required-property error(s): …" — each written as Product is missing required property "name".
• "*N* recommended field(s) missing: …" — each written as Product is missing recommended property "aggregateRating".
• Microdata and RDFa types, listed separately when present.

Two special findings deserve attention because they change how you read everything else:

• Blocked fetch: "The page returned HTTP N, so its HTML could not be read. This is usually bot protection on the site, not missing structured data." Every count below it will read zero and none of them mean anything.
• JavaScript-rendered: "No structured data in the initial HTML, but the page is JavaScript-rendered — schema may be injected client-side. Confirm in Google Rich Results Test, which renders JS." Your markup may be perfectly fine; this tool reads the HTML as delivered, before scripts run.

Recommended Next Steps. A numbered list built from the findings — fix invalid JSON, add a primary type, add each named missing required property, add recommended fields, and validate every change in Google's Rich Results Test before deploying.

Rich-Result Types You Could Add. The types that can produce an enhanced result and are not yet on the page: Product, Article, NewsArticle, BlogPosting, FAQPage, HowTo, Recipe, Event, Course, VideoObject, LocalBusiness, BreadcrumbList and SoftwareApplication. Only add what the page genuinely is — marking a blog post as a Product is a manual-action risk, not a shortcut.

Detected Schema Types. Every type found, color-coded, with primary types (the ones search engines act on) distinguished from supporting ones.

Google Search Preview. A mock search result per rich-result type detected, built from your real values — a Product preview shows your product name, price and rating; an Article preview shows your headline. This is what the markup buys you.

All JSON-LD Blocks. Each block in order with its index, whether it parsed, the types inside it, its item count, its errors and warnings, and the full raw JSON formatted for reading. When a block is invalid the parse error is shown as Invalid JSON: … with the message from the parser, which usually points at the character that broke it.

The validation rules. Required properties are errors, recommended ones are warnings:

Examples#

Screenshots#

Tips#

• Validate one page of each template rather than every page — schema is generated by templates, and the results repeat.
• Copy the raw JSON from All JSON-LD Blocks straight into a ticket; it is the exact markup that shipped.
• Fix invalid blocks before adding new types. An unparseable block contributes nothing, so extending it is wasted work.
• If the page is JavaScript-rendered, confirm with Google's Rich Results Test, which executes JavaScript before checking.
• Organization, WebSite and BreadcrumbList belong on essentially every page. They are the cheapest structured data you will ever add.

Best Practices#

• Prefer JSON-LD over microdata and RDFa. It is what Google recommends, it lives in one block, and it does not entangle your markup.
• Fill the recommended properties, not just the required ones. Required makes a block valid; recommended is usually what makes the rich result actually appear.
• Only mark up what is genuinely on the page. Structured data that does not match the visible content is a manual-action risk.
• Re-validate after every CMS, theme or plugin update.
• Keep one block per entity and use @graph when a page describes several things — the tool walks @graph correctly.

Common Mistakes#

• Assuming valid means eligible. A valid block missing a required property is still ineligible for its rich result. Read the errors, not just the Valid tile.
• Reading a blocked fetch as "no schema". If the page returned a non-200 status, every count is meaningless until you can fetch the page.
• Ignoring the JavaScript-rendered warning. Your schema may exist and simply arrive after the HTML does.
• Marking up content that is not visible. Prices and ratings in schema must match what a visitor sees.
• Adding a fourth type instead of fixing the invalid first one. Google ignores the invalid block entirely, so it is a zero, not a partial credit.

Limitations#

• No JavaScript rendering. The page is fetched, not rendered. Client-side schema is detected only as a warning that the page is framework-built.
• 20 types are validated. Types outside the rule table are detected and listed, but their properties are not checked.
• Microdata and RDFa are detected, not validated. Only their types and item counts are reported.
• One page per run. There is no bulk mode.
• Each raw block is shown up to 60,000 characters, then truncated.
• This is not Google's validator. Google's Rich Results Test is the final authority on eligibility; use this to find and fix problems quickly, and Google to confirm.

Troubleshooting#

FAQs#

Does this cost credits? No. It is one of the zero-credit technical tools and runs on every plan, including Free.

It says I have no structured data, but I installed a schema plugin. What is wrong? Most likely the plugin injects schema with JavaScript. This tool reads the HTML as delivered, so client-side schema is invisible to it — and it will tell you when it detects a JavaScript-rendered page. Confirm with Google's Rich Results Test, which renders JavaScript.

What is the difference between an error and a warning here? An error is a missing required property — the block cannot produce its rich result. A warning is a missing recommended property — the block is valid but weaker, and often will not earn the enhanced result in practice.

Will valid schema make me rank higher? Structured data is not a ranking factor by itself. What it changes is how your result looks: stars, prices, FAQs and breadcrumbs take more space and earn more clicks at the same position.

How does it handle @graph? It walks it. Types nested inside @graph, inside arrays and inside other objects are all collected and validated, which is why the type count here can be higher than a naive parser reports.

Should I use JSON-LD, microdata or RDFa? JSON-LD. The tool detects all three, but JSON-LD is what Google recommends and the only one it validates property-by-property here.