schema

Validating structured data: missing, partial, invalid

Three ways JSON-LD fails, which validator catches which, the errors that recur, and how to audit structured data across a site by template instead of by URL.

Structured data fails in three ways, and each one needs a different check. Missing means the page has no markup for what it is. Invalid means the markup is there but doesn’t parse, so no consumer can read any of it. Partial means it parses but leaves out properties the type needs, so it describes the page incompletely. A validator built for one of these failures can report a clean result on a page that has another.

Google’s Rich Results Test checks markup against Google’s own feature requirements. The Schema Markup Validator checks it against schema.org without Google’s rules. Search Console reports on a sample, and only for rich-result types. None of them audits a whole site’s structured data in one pass, and none tells you a page should have markup it doesn’t have. This post covers what each tool is for, the errors that recur, and how to audit by template.

What it won’t do is claim that valid markup earns a citation. Structured data states facts about a page in a form machines can read without inference. Whether any answer engine uses those facts in selection is mostly undocumented, as The schema stack that matters for AEO and GEO sets out. Validation makes sure that what you declare is readable and true.

What do missing, partial, and invalid mean?

The three states describe how far a page gets before its markup stops being useful.

StateWhat’s wrongWho noticesTypical cause
MissingNo markup describing the page’s main entityNo validator; only an audit that knows what the page isTemplate never had it; plugin disabled; markup on some page types only
InvalidThe JSON doesn’t parseEvery validator, and Search Console’s Unparsable structured data reportTrailing comma, unescaped quote, smart quotes, CMS injecting HTML into a string
PartialParses, but required or expected properties are absent or wrongRich Results Test for Google-supported types; your own rules for othersTemplate fills only some fields; a field is empty on some pages

Invalid is the most severe, because a single syntax error makes the whole block unreadable, not just the broken property. Missing is the most common in audits, and the one tools are worst at catching, because a validator can only validate what’s there.

GEOBee uses the same three words. When a page’s JSON-LD is absent or broken it reads as None, Invalid, or Partial, and the scan validates required fields for the types it detects, such as a headline on an Article and a name and offers on a Product (the three lenses lists the detected types).

Rich Results Test or Schema Markup Validator: which one?

Use both, for different questions. Google’s structured data documentation describes the Rich Results Test as “the official Google tool for testing your structured data to see which Google rich results can be generated,” and says to use the Schema Markup Validator “to test all types of schema.org markup, without Google-specific validation.”

In practice:

  • Rich Results Test answers “does Google consider this eligible for a rich result, and if not, which required property is missing?” It’s the right check for types Google supports as rich results, like Product or Article. It says little about types Google doesn’t use for a feature: markup of such a type can pass the Schema Markup Validator cleanly and produce no detected rich result in the Rich Results Test. Neither result means anything is wrong.
  • Schema Markup Validator answers “is this valid schema.org?” It parses every type and flags properties that don’t exist on a type or values of the wrong kind. It doesn’t know Google’s required-property lists.

Both test one URL or one code snippet at a time. Run a page through both when you’re fixing a template; use neither as a site audit.

What does Search Console show, and what doesn’t it?

Search Console shows structured data Google found while crawling, for rich-result types only, and as a sample. Google’s rich result status reports documentation says the reports “show a sample of detected items” and “aren’t a comprehensive list of all detected items.” There’s a separate report for each supported rich result type, and an item is invalid when it “has at least one critical issue preventing it from appearing as a rich result.” Non-critical issues appear separately, in an “Improve item appearance” table.

The Unparsable structured data report catches the invalid state across the property. It “lists structured data found on your site that could not be parsed because of a serious syntax error,” with error types such as an invalid JSON document, a missing colon, a duplicate unique property, a bad escape sequence, and an invalid number.

So Search Console covers invalid markup well and partial markup for rich-result types. It doesn’t cover missing markup, and it doesn’t cover types like Organization or Person outside their rich-result uses. Use the URL Inspection tool to confirm what Google saw on a specific URL after you ship a fix; Google’s introduction to structured data recommends both the URL Inspection tool and the rich result status reports after deployment.

What are the most common JSON-LD errors?

Most errors come from templates and content management systems, not from people typing JSON by hand. The ones that recur:

Syntax that breaks parsing. A trailing comma after the last property. A double quote inside a string that isn’t escaped, usually from a product name or a quote in a description. Curly “smart” quotes substituted for straight ones by an editor. A backslash sequence JSON doesn’t allow. Any of these makes the whole block invalid.

HTML inside a string. A CMS field rendered into the JSON with its tags, entities, or line breaks intact. "description": "<p>Fast &amp; light</p>" parses, but the value is markup, not text.

Empty values. "author": "" or "price": "" because the field was blank for this page. The block parses and validates as syntax, but the property says nothing, and for required properties the item is partial.

Wrong value types. A string where an object is expected ("author": "Jane Doe" where the type wants a Person or Organization), a price with a currency symbol in it, a date that isn’t ISO 8601. The Schema Markup Validator flags some of these; Google’s tests flag the ones that matter for its features.

Conflicting blocks. A theme emits one Organization block, a plugin emits another, and the two disagree on the name or logo. Each block can be valid on its own.

Markup that describes something the page doesn’t show. Google’s structured data policies say “Don’t mark up content that is not visible to readers of the page,” and that structured data “must be a true representation of the page content.” FAQPage markup for questions that aren’t on the page, review ratings that aren’t displayed, a price that differs from the visible one: these pass every syntax check. They fail the only check that matters, which is whether the markup is true. FAQ sections: leverage or filler covers the FAQ case.

How do you check one page by hand?

View source and search for application/ld+json. For each block you find:

  1. Copy its contents into the Schema Markup Validator’s code tab. If it reports a parse error, the block is invalid; fix that first.
  2. Run the URL through the Rich Results Test if the type is one Google supports for a rich result. Note any missing required properties.
  3. Read the values against the visible page. Same name, same price, same author, same dates. Check dateModified against when the page actually changed; Freshness signals and honest dateModified covers why that one gets faked.
  4. Ask whether anything is missing. A product page with only BreadcrumbList markup has valid structured data and no Product. A blog post with Article markup and no author has a partial item.

Step 4 is the step tools can’t do for you, because it depends on knowing what the page is. Product pages that answer engines can quote, Author bylines and Person schema, and Organization schema and sameAs cover what each page type should carry.

How do you audit structured data across a whole site?

Audit by template, not by URL. Structured data is almost always generated by templates, so a fault on one product page is usually a fault on all of them, and a fault that appears on only some pages of a template usually traces to an empty CMS field.

The non-terminal method:

  1. Crawl and extract. Most desktop crawlers can extract structured data, or let you set a custom extraction rule for script[type="application/ld+json"]. Extract the @type values and a parse status per URL.
  2. Pivot in a spreadsheet. Add a column for the template (usually derivable from the URL path), then pivot template against type. Each template should show the types you expect on every page. A blank cell is missing markup; a count below the template’s page count means some pages lack it.
  3. Sample each template in the validators. Take three URLs per template, including one with unusual content (a long title, a product with no price, a post with two authors), and run them through both tools. Edge cases are where partial and invalid items come from.
  4. Cross-check Search Console. The Unparsable structured data report and the per-type rich result reports give you Google’s sample, which catches pages your crawl didn’t reach.

If you’re comfortable in a terminal, this checks whether every JSON-LD block on one page parses, and prints each block’s type:

curl -s https://example.com/product/ | python3 -c '
import sys, re, json
html = sys.stdin.read()
for raw in re.findall(r"<script[^>]*application/ld\+json[^>]*>(.*?)</script>", html, re.S):
    try:
        data = json.loads(raw)
        items = data if isinstance(data, list) else [data]
        print("OK     ", [i.get("@type") for i in items])
    except json.JSONDecodeError as e:
        print("INVALID", e)
'

Run it against a list of URLs and you have parse status at scale. It doesn’t check required properties or truthfulness; the validators and a person still do that.

In GEOBee, the Schema column in the grid and the CSV export shows each URL’s detected type or None, Invalid, or Partial, and the page detail panel has a Schema tab with the evidence. Work through Invalid first, then Partial, then None on templates that should carry markup. That’s the order Prioritizing AEO fixes would give you anyway: invalid markup is a broken signal, partial is a weakened one, and missing is only a problem on pages that need it.

What should you fix first?

Fix invalid markup first, then markup that contradicts the visible page, then partial items on high-value templates, then missing markup. Invalid blocks deliver nothing until they parse. Contradictions are a policy problem as well as a data problem. Partial and missing items are gaps rather than errors, and they’re worth closing in order of the pages’ value.

After shipping a template fix, re-crawl and compare. The template’s pages should move from Invalid or Partial to a detected type together; any that don’t are pages where the content, not the template, is the cause. For the broader citability picture structured data sits inside, see Citability and entity signals: a GEO guide.

To see the Schema state of every URL on a site at once, on your own machine, download GEOBee and run the 7-day trial.

On this page