Structured Data Errors: How to Validate Schema Markup and Fix Rich Result Issues

Structured data implementation can fail in two ways: technically invalid markup that doesn’t parse correctly, and valid markup that doesn’t meet Google’s content guidelines for rich result eligibility. Both result in no rich results in search — but they’re diagnosed and fixed differently. Understanding how Google validates structured data and what disqualifies pages from rich results is the foundation of effective schema markup troubleshooting.

How Google Processes Structured Data

When Googlebot crawls a page, it extracts structured data from three possible sources:

JSON-LD (JavaScript Object Notation for Linked Data) — Google’s preferred format, embedded in a <script type="application/ld+json"> tag
Microdata — HTML attributes integrated into the page markup (itemscope, itemtype, itemprop)
RDFa — Another HTML attribute-based format

Google checks the extracted structured data against schema.org vocabulary definitions, validates required and recommended properties, and then applies its own content quality guidelines on top. Passing schema.org validation is necessary but not sufficient — Google adds eligibility requirements beyond technical validity.

Google’s Validation Tools

Rich Results Test (search.google.com/test/rich-results): Google’s primary tool for validating structured data. Shows:

Whether the page is eligible for rich results
Which schema types were detected
Missing required properties
Errors and warnings
A preview of how the rich result might appear

Run this on any page where you’ve implemented schema markup before deploying.

Google Search Console — Rich Results Report: Shows rich result performance across your site over time — impressions, clicks, and a breakdown of valid/warning/error pages per schema type. This is where you see the aggregate impact of structured data issues rather than individual page validation.

Schema.org Validator (validator.schema.org): Validates markup against schema.org definitions without Google’s additional eligibility criteria. Useful for checking whether markup is syntactically correct before testing rich result eligibility.

Common Structured Data Errors

Missing required properties:

Each rich result type has required properties without which Google won’t generate a rich result. Common examples:

Recipe: Missing name, image, or recipeIngredient
Product: Missing name (required), or missing offers for price markup
FAQ: Missing acceptedAnswer or acceptedAnswer.text
HowTo: Missing step or steps missing text
Review: Missing reviewRating or author

The Rich Results Test reports these as errors with specific property names.

Invalid property values:

Property values must match expected types:

ratingValue should be a number (or numeric string), not “five stars”
datePublished requires ISO 8601 format: "2026-05-16T00:00:00Z", not “May 16, 2026”
image requires an absolute URL, not a relative path
url requires a full absolute URL including protocol

Incorrect nesting:

Schema types often have nested structures. A Product containing AggregateRating must nest it correctly:

{
  "@type": "Product",
  "name": "Product Name",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.5",
    "reviewCount": "89"
  }
}

Flat structures where nested properties are placed at the wrong level fail validation.

Multiple conflicting schema blocks:

If a page has multiple <script type="application/ld+json"> blocks, Google processes all of them. Conflicting definitions (two Article blocks with different dates) can produce unexpected results. Consolidate to one block per type, or use a single array-based definition.

Markup not matching page content:

Google’s rich result eligibility guidelines require structured data to accurately represent the page content. A Product schema with a 5-star rating when no reviews exist on the page fails content guidelines. A FAQ schema with questions that don’t appear in the page body is disqualified. This is enforced through a combination of algorithmic checks and manual review.

Rich Result Eligibility Beyond Technical Validity

Technical validity is required but doesn’t guarantee rich results. Google applies additional criteria:

Content quality requirements: Pages must have substantive content that serves the user. A page that’s mostly ads with minimal content won’t receive rich results even with valid schema.

Spam policies: Pages violating Google’s spam policies — thin content, doorway pages, manipulative structured data — won’t receive rich results and may receive manual actions for structured data spam.

Page-level vs. site-level eligibility: Google may withhold rich results from a technically valid page if the site has a history of structured data abuse or if the rich result type is being used in misleading ways.

Rich result type availability: Not all schema types generate rich results in all contexts. The officially supported rich result types are documented at developers.google.com/search/docs/appearance/structured-data/search-gallery.

Diagnosing Rich Result Loss

If previously working rich results disappeared:

Run the Rich Results Test on the specific page — check for new errors
Check GSC Rich Results Report for the affected type — look for a trend of increasing errors
Check whether the page content changed (rich result content must match page content)
Check whether a Google algorithm or policy update affected that rich result type
Check whether a CMS update modified how schema markup is output

The GSC Rich Results Report shows the date dimension — correlating a rich result drop with a deployment date narrows the root cause significantly.

Automating Structured Data Validation

For sites with large numbers of pages using structured data (e-commerce product pages, recipe sites, FAQ pages), manual validation is impractical. Automated approaches:

Run Rich Results Test API calls on a sample of pages after each deployment
Include schema validation in CI/CD pipelines using schema.org validator libraries
Monitor GSC Rich Results Report for error count trends and alert on significant increases
Crawl with Screaming Frog and extract structured data to validate in bulk

Structured data implementation that passes initial testing can break months later when CMS updates, template changes, or content changes invalidate the schema. Continuous monitoring prevents long periods of undetected rich result loss.