Schema Markup Validator: How to Test and Fix Your Structured Data

Broken structured data costs you rich results and AI citations

Learn how to test, interpret, and fix your schema markup so search engines and AI agents can actually read your pages.

Broken structured data costs you rich results and AI citations

Test and fix your structured data today

Validate your schema markup now and stop losing rich results to fixable errors.

Test your schema markup

What schema validation actually checks and why it matters

Schema markup is structured data embedded in your page that tells search engines and AI agents what your content means, not just what it says. Written in JSON-LD, Microdata, or RDFa, it describes entities like products, reviews, events, and FAQs in a vocabulary that machines can parse reliably.

Validation is the process of verifying that your structured data follows Schema.org standards and Google's Rich Results guidelines. A validator checks two layers: syntax (is the JSON itself valid?) and semantics (does the markup use the right types and properties for the schema you're declaring?). It flags errors, where a required property is missing or the JSON fails to parse, and warnings, where a recommended property is absent and may limit what search engines can show.

For AI search specifically, this matters more than ever. AI agents that generate answers from web content rely on structured signals to identify entities, relationships, and facts with confidence. Markup that doesn't parse cleanly is markup that gets ignored.

The main validator tools and when to use each

Two tools dominate the validation workflow, and they serve different purposes.

Google's Rich Results Test goes beyond syntax: it confirms that Google specifically can parse your markup and tells you which rich result your page qualifies for under Google's current guidelines. Those guidelines are sometimes stricter than the general Schema.org spec. FAQ schema eligibility is a well-documented example where Google's rules diverge from the base vocabulary.

Schema.org's Markup Validator (schema.org/SchemaValidator) is the strict grammar check. It confirms your JSON-LD is syntactically correct and matches the official Schema.org vocabulary. It went live in May 2021 and officially replaced Google's Structured Data Testing Tool on August 9th, 2021, after community pushback over the SDTT's retirement.

Use both in sequence: Schema.org's validator to confirm the markup is structurally sound, then Google's Rich Results Test to confirm it qualifies for the specific rich result you're targeting. Neither tool alone gives you the full picture.

The most common errors validators surface

Most schema errors fall into a small number of categories, and knowing them in advance makes the fix faster.

Syntax errors are the most disruptive. JSON-LD depends on correctly placed commas, curly brackets, and square brackets. A single missing comma can invalidate the entire block, and the validator will report a parse failure rather than a property-level warning.

Missing required properties are the next most common issue. Each schema type has properties that search engines expect. A Product schema without a `name` or `offers` property, for example, will fail the Rich Results Test even if the JSON itself is valid.

Relative URLs are a subtler trap. Providing `/images/product-photo.jpg` instead of `https://www.example.com/images/product-photo.jpg` triggers a validation error because a relative URL is not a valid URL type in the schema. A browser resolves relative paths automatically; a schema validator does not.

Incorrect `@context` or `@type` declarations and mismatched data types (a number where a URL is expected, for instance) round out the most frequent issues.

Rich results eligibility and what valid markup unlocks

Passing validation is not the end goal. The goal is eligibility for rich results: the enhanced search listings that display star ratings, FAQ dropdowns, product pricing, event dates, recipe details, and more directly in search results.

Rich results can boost click-through rates by up to 82%, which makes the difference between a page that ranks and a page that actually gets clicked. Review stars and FAQ snippets are among the highest-impact formats, and both require clean, validated markup to qualify.

For AI search, the stakes are similar. AI agents parsing your page to generate an answer look for structured signals that confirm what your content is about. Valid schema markup strengthens entity signals, making it easier for an AI agent to attribute facts, prices, ratings, or services to your business specifically. Pages without valid structured data are harder to cite with confidence, which means they appear less often in AI-generated answers.

How schema validation fits into an ongoing content strategy

A one-time validation pass is not enough. Schema markup breaks when CMS templates are updated, when plugins conflict, when new page types are added, or when Google changes its rich results guidelines. Any of those events can silently invalidate markup that was clean the day before.

Building validation into a regular content workflow, rather than treating it as a one-off audit, keeps rich results eligibility stable over time. Tools that crawl your site at scale and surface structured data errors across all pages, rather than one URL at a time, make this practical for larger sites.

For businesses focused on AI search visibility, structured data is one of the clearest signals an AI agent can use to understand and cite your content. Platforms like Miracly generate structured content pages engineered to be parsed by AI agents, with schema markup built in, and track citation performance across AI engines in real time. That positions schema not as a technical checkbox but as an active part of how your brand gets found and cited in AI-generated answers.

If an AI agent cannot parse your structured data, your content does not exist in the answer.

How to validate and fix your schema markup

  1. Paste your URL or code snippet

    Open Google's Rich Results Test or Schema.org's Markup Validator. You can either enter a live page URL, which causes the tool to fetch the page and extract all structured data blocks, or paste raw JSON-LD code directly. Pasting code directly is useful when you want to test markup before it goes live, or when the page is behind a login or staging environment that the crawler cannot reach.

  2. Run the validation and read the report

    The tool parses your structured data and returns a report divided into detected schema types, errors, and warnings. Errors are blockers: they prevent the markup from qualifying for rich results. Warnings are advisory; they flag recommended properties that are missing but won't break the markup entirely. Read each item carefully, because the report names the specific property and the schema type it belongs to, which tells you exactly where to look in your code.

  3. Locate and fix the flagged code

    Go to the page source, your CMS's structured data field, or the plugin generating the markup. For syntax errors, look for the line number the validator reports and check for missing commas, unclosed brackets, or mismatched quotation marks. For missing required properties, add the property with a correctly formatted value. For relative URL errors, replace paths like `/images/photo.jpg` with fully qualified URLs like `https://www.example.com/images/photo.jpg`.

  4. Re-test until the report is clean

    After making changes, paste the updated code back into the validator, or re-fetch the live URL if you have already published the fix. Repeat the test-fix cycle until the report shows no errors. Aim to resolve all warnings for high-priority schema types like Product, Review, and FAQ, since recommended properties directly affect how much information search engines can display in rich results.

  5. Monitor for regressions over time

    Schema markup can break silently after CMS updates, theme changes, or plugin conflicts. Set a recurring schedule to re-validate key page types, particularly any page that currently earns a rich result in search. Google Search Console's Enhancements reports also surface structured data errors detected during crawling, making it a useful complement to manual validation for ongoing monitoring.

Benefits

  • Rich results eligibility restored

    Valid schema markup is the prerequisite for enhanced search listings. Star ratings, FAQ dropdowns, product pricing, and event details only appear when the underlying structured data passes validation without critical errors.

  • Stronger AI citation signals

    AI agents use structured data to identify entities and attribute facts with confidence. Clean, parseable markup makes your content easier to cite in AI-generated answers, improving your visibility in ChatGPT, Perplexity, Google AI Overviews, and similar engines.

  • Fewer crawl errors and indexing gaps

    Broken JSON-LD blocks can generate structured data errors in Google Search Console that accumulate over time. Resolving them keeps your crawl reports clean and removes a category of technical noise that can distract from genuine content issues.

  • Clearer entity signals for competitive queries

    Correctly typed schema markup tells search engines and AI agents what your business is, what it offers, and how it relates to other entities. Strong entity signals improve your relevance for competitive queries where AI agents are choosing between multiple sources to cite.

Schema markup validator: common questions answered

Which schema validator is most reliable for testing structured data?

Use both Google's Rich Results Test and Schema.org's Markup Validator together for the most complete picture. Schema.org's validator confirms your JSON-LD is syntactically correct against the official vocabulary, while Google's Rich Results Test confirms whether Google specifically can parse the markup and which rich result the page qualifies for. Neither tool alone covers both layers.

Do warnings matter, or only errors?

Errors are blockers that prevent rich results eligibility entirely. Warnings flag recommended properties that are missing but won't break the markup. For high-priority schema types like Product, Review, and FAQ, resolving warnings is worth the effort because recommended properties directly affect how much information search engines can display in rich results.

How often should I re-validate my schema markup?

Schema markup can break silently after CMS updates, plugin changes, or theme edits, so a one-time validation is not enough. Re-validate whenever you update page templates, install new plugins, or add new page types. Google Search Console's Enhancements reports also surface crawl-detected errors between manual checks.

Does schema markup directly affect AI search visibility?

Structured data is one of the clearest machine-readable signals an AI agent can use to understand and attribute your content. Valid schema markup strengthens entity signals, making it easier for AI agents in engines like ChatGPT, Perplexity, and Google AI Overviews to cite your content with confidence. Pages with broken or missing markup are harder to cite accurately.

What happens if my schema markup is valid but I still don't get rich results?

Passing validation is a necessary condition for rich results, not a guarantee. Google applies additional eligibility criteria, including content quality signals and policy compliance, before showing a rich result. Some schema types, like FAQ, have also had their eligibility criteria narrowed over time, so a type that qualified previously may no longer qualify under current guidelines.

What is the difference between JSON-LD, Microdata, and RDFa?

All three are formats for writing structured data that schema validators can check. JSON-LD is Google's recommended format for most use cases because it can be placed in the `` section of your HTML without affecting the visual appearance of the page. Microdata and RDFa embed attributes directly into HTML elements, which makes them harder to maintain and audit.

Fix your schema markup and get cited by AI search engines

Schema errors are fixable, but only once you know where they are. Run your pages through a validator, work through the error report systematically, and re-test until the markup is clean. If you want structured data that is built correctly from the start and engineered for AI agent readability, Miracly generates and manages schema-backed content pages designed to be cited across AI search engines.

See how Miracly works