Schema Audit — All Structured Data on a Page

What this tool does

Most pages with structured data have it half-implemented. There is an Article schema, but it is missing the image and dates Google recommends; there is a Product schema, but no offer block with price and currency; the page shows a breadcrumb trail, but nobody added the BreadcrumbList schema that would put it in the search result. A line-by-line schema validator catches the syntax errors. What you actually need to know is broader: which schemas are present, which are missing, which are incomplete, which would qualify for which rich results if you fixed one or two fields, and what the biggest leverage moves are. That is what this audit produces.

Enter a page's URL, or paste its complete HTML source, and the audit walks the page in four passes. Format detection finds every JSON-LD block, every Microdata item (itemscope) and every RDFa item (vocab and typeof), and reads each into a full object with its nested items. Validation checks each schema's types, properties and values against schema.org, and each against Google's search feature requirements, reporting retired features such as FAQ rich results as retired. Completeness scoring measures how many recommended properties are populated for each detected type. Opportunity detection reads the page's visible structure for schema types that should exist but do not — a breadcrumb trail without a BreadcrumbList, a recipe without a Recipe schema. The audit runs in your browser: pasted source isn't uploaded, and a page checked by its URL is fetched by our server as SchemaBizBot and sent back to your browser to be audited. For a page checked by URL, a page panel adds what the page says about itself: its canonical link compared with the address that was fetched, its og:url, title and language, and any robots rules that keep it out of Google's index.

When to use the Schema Audit

Quarterly schema maintenance pass. Schemas drift. A template that produces clean structured data today produces under-populated markup six months later as the content model evolves. A scheduled audit on each template catches drift before it costs eligibility.

After a major template redesign. Template rewrites are the most common cause of schema regressions — the old template emitted Organization and BreadcrumbList schemas, the new template kept only the Article. Run the audit on the new template before merging the redesign and the regressions are visible.

Reverse-engineering a competitor's markup. A competitor consistently appears with rich results you do not have. Audit one of their pages and the report will tell you exactly which schemas they implement and how completely. The opportunity detection tells you which patterns on your own pages would produce the same eligibility.

The discovery phase of an SEO engagement. When you take over a site for the first time, the audit gives you a one-page summary of where structured data stands across each template. The quick-wins prioritization gives the first sprint's worth of work without a separate planning phase.

Walkthrough with a real example

Paste this page source — a blog article with an Article schema, a visible breadcrumb nav and a question-and-answer section, but no BreadcrumbList schema:

<!doctype html>
<html>
<head>
  <title>Why we rebuilt our checkout flow | Example Co Blog</title>
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "Why we rebuilt our checkout flow",
    "datePublished": "2026-03-14",
    "author": { "@type": "Person", "name": "Sam Patel" }
  }
  </script>
</head>
<body>
  <nav aria-label="breadcrumb">
    <a href="/">Home</a> / <a href="/blog">Blog</a> / Why we rebuilt
  </nav>
  <article>
    <h1>Why we rebuilt our checkout flow</h1>
    <p>Posted March 14, 2026 by Sam Patel</p>
    <img src="/posts/checkout-rebuild.jpg" />

    <h2>Frequently asked questions</h2>
    <h3>Why did you rebuild instead of refactoring?</h3>
    <p>The legacy code path had three branches that all needed...</p>
    <h3>How long did the rebuild take?</h3>
    <p>Eleven weeks from kickoff to full rollout...</p>
  </article>
</body>
</html>

The audit reports:

Found 1 schema type · 2 warnings · 1 missing opportunity

Article (json-ld) · Completeness 38%
  WARNING  image: Google recommends image for Article.
  WARNING  dateModified: Google recommends dateModified for Article.
  Rich result eligibility: ELIGIBLE Article

Missing opportunities
  high  Add BreadcrumbList schema: breadcrumb navigation detected

Quick wins
  moderate  Expand Article schema (38% complete)
  minimal   Add dateModified
  easy      Add BreadcrumbList schema

The existing Article schema is valid, and because Google's Article markup has no required properties, it's eligible for the Article rich result. The audit still warns about two properties Google recommends: image (the page has an image, but the markup doesn't reference it) and dateModified. Completeness is 38%: three of the eight properties the audit tracks for an Article are present (headline, datePublished and author), and image, dateModified, publisher, description and url are missing. The AI readiness score is low for the same reasons: no description, no URL, no sameAs links, no publisher and only one date.

The opportunity detector found the breadcrumb nav, identifiable by its aria-label="breadcrumb", and suggests a BreadcrumbList schema. It doesn't suggest FAQPage for the question-and-answer section: Google stopped showing FAQ rich results on May 7, 2026, so that markup no longer earns a rich result.

The quick-wins panel turns the findings into tasks with an effort level: expand the Article (moderate), add dateModified (minimal), and add the BreadcrumbList (easy, because the breadcrumb content is already on the page).

Schema audit concepts you should know

Validation versus completeness versus opportunity detection. A validator confirms the schema is well-formed. A completeness check measures how many recommended properties are populated. Opportunity detection looks at the page contents and suggests schema types that should exist. The three layers answer different questions: "is the schema valid?" / "is it as good as it could be?" / "are there schemas missing?" — and a serious audit needs all three.

Rich result eligibility versus AI search readiness. Rich result eligibility is a binary: does the schema satisfy Google's documented requirements for a given rich result? AI search readiness is a score: how clearly does the schema communicate the entity, its relationships, and its freshness to AI engines like ChatGPT Search, Perplexity, and Google's AI Overviews? A schema can be rich-result eligible but AI-thin (an Article with author and image but no sameAs on the author, no datePublished/dateModified pair, no mainEntityOfPage). The audit reports both.

The four output dimensions. Per-schema validation results (errors, warnings, passed checks). Per-schema completeness percentage. Per-page missing schema opportunities. Cross-cutting quick wins, sorted by effort. Reading them in that order — validate first, complete next, expand third, prioritize fourth — produces a roadmap that matches the underlying difficulty of the work.

How missing-opportunity inference works. The audit reads the page as the browser would, with scripts and styles set aside, so a word inside JSON-LD or CSS is never evidence. Each suggestion needs structure on the page: an element marked as a breadcrumb with at least two links suggests BreadcrumbList; an "Add to cart" or "Buy now" button together with a price suggests Product; an "Ingredients" heading followed by a list suggests Recipe; a date in a <time> element with a tickets or register link suggests Event; two of a postal address, a phone link and opening hours suggest LocalBusiness; a logo image suggests Organization. A type that's already in the page's markup, even nested or as a subtype, counts: a Dentist is a LocalBusiness and an Organization, so neither is suggested. It never suggests FAQPage, HowTo or a sitelinks search box, because Google no longer shows those rich results. The evidence is listed with each suggestion; check it against the page before acting on it.

Freshness signals. AI search engines weight freshness heavily. A schema with datePublished alone signals the original publication. A schema with both datePublished and dateModified, where dateModified is recent, signals active maintenance. A schema with neither signals an unmaintained page. The completeness score counts both dates for articles, and the AI readiness score rewards a recent dateModified on articles and other content.

Cross-format coexistence. Pages can host JSON-LD, Microdata, and RDFa simultaneously — and many do, because plugins inject one format while the theme injects another. The audit lists every item with its format, and flags an Organization, WebSite or Person that's described more than once without a shared @id. When the same entity is described in several formats with different data, decide which one is canonical (which one does Google trust?) and remove the others.

Common mistakes

Auditing one page and assuming the rest of the site is fine. Schemas are template-level. An audit on the homepage tells you nothing about the product template. Run the audit on every distinct template, not on a single sample page.

Validating without measuring completeness. A schema can pass validation while populating only the bare minimum of fields. The rich result will not appear, even though the schema is "valid." Check the completeness score, not just the validation verdict.

Ignoring AI search signals. Optimization for traditional rich results and optimization for AI engines overlap but are not identical. A schema that is rich-result-eligible but AI-thin will hold its SERP rich result and lose to better-marked-up competitors when users move to ChatGPT Search or Perplexity. The AI score is not optional anymore.

Not refreshing dateModified. A page that was edited yesterday but still shows last year's dateModified looks unmaintained to both Google and AI engines. Bind dateModified to the underlying content's actual modification time, not to the page's deployment time.

Letting plugin-generated schemas accumulate alongside hand-coded ones. A CMS plugin injects an Organization schema, the developer adds another, and now there are two competing entity descriptions. Audit for duplicates, decide which is canonical, and remove the other.

FAQ

Can I audit a page by its URL?

Yes. Choose Check a URL and enter the address, or open schema.biz/markup/audit/?url= followed by it. Our server fetches the page as SchemaBizBot, following up to 5 redirects and reading up to 5 MB within 10 seconds, and the audit runs in your browser on its HTML. Above the report, a page panel shows the address that was fetched and its status, the page's canonical link compared with that address, its og:url, title and language, and robots rules, including an X-Robots-Tag header. The page is kept only in a 10-minute cache; we record its address without the query string, as the privacy policy describes.

Does this audit my whole site, or one page?

One page per audit, checked by its URL or its pasted source. There's no crawler, so a site-wide audit means one audit for each template (homepage, blog post, product, category, search results). Most site-wide schema problems are template-level, so a five-template audit covers what a thousand-page crawl would surface.

Can I audit pages behind authentication?

Yes — paste the rendered HTML directly. Check a URL can't reach them, because our server fetches pages without your login. After signing in to the page yourself, view the page source (right-click → View Page Source, or Ctrl+U / Cmd+U), select all, copy, paste into the input. The audit runs in your browser and never uploads what you paste, so the page contents stay on your machine even though the page is behind auth. We do record the page's address from its canonical link or og:url (without the query string), with the schema types and issues found, never its content; see the privacy policy.

Does it handle JSON-LD that is injected by JavaScript after the page loads?

If you paste the static page source, or check the page by its URL, only schemas present at server-render time are visible; a URL check says so when the page shows signs of adding markup with a script. To audit hydration-time schemas, open DevTools, copy the rendered HTML from the Elements panel after the page settles, and paste that. The audit then sees the post-hydration DOM the way Google's rendered HTML pipeline does.

How is this different from running a full SEO crawler?

An SEO crawler walks every URL on a site, captures titles and meta tags, finds broken links, and produces a sitemap-level view. The schema audit goes deep on a single page's structured data: completeness scoring, missing-type inference from HTML patterns, AI readiness, and quick-win prioritization. Use both — a crawler for site coverage, this audit for per-template depth.

How often should the audit be rerun?

After every template change, after every Google rich-result feature launch, and on a quarterly cadence as a maintenance pass. Schemas drift when content evolves — a template that produces clean Article markup today can drift into producing under-populated markup six months later as the surrounding content changes shape. The quarterly run catches drift before it costs visibility.

Related tools and guides

Schema Markup Validator — when the audit reports a validation error on a specific schema, lift the schema out and validate it in isolation to iterate on the fix.
AI Search Optimizer — the audit gives you the AI readiness score; the optimizer takes a single schema and walks you through the changes that raise it.
JSON-LD Generator — the cleanest way to add the schemas the audit's opportunity detector flagged is to generate them from a form rather than hand-author the JSON.
Schema Markup Beginner's Guide — covers the foundational concepts the audit assumes: types, properties, JSON-LD structure, and how Google uses them.
Structured Data for AI Search — the optimization layer the audit's AI readiness score is built around: which signals AI engines actually weight and how to populate them.

Schema Audit Tool