SchemaForAI
Ad

Free Schema Markup Validator for AI Search

Paste any JSON-LD and we'll check the syntax, required fields, and AI-readiness rules in your browser. Instant, no sign-up, no data leaves your device.

Paste your schema

Try an example:
0 characters

Results

Paste your JSON-LD and click Validate. We'll check the JSON syntax, required fields per type, and common Google Rich Results pitfalls.

What is Schema Validation?

Schema validation is the process of checking your JSON-LD structured data against two independent contracts: the Schema.org vocabulary specification (which defines what @types and properties exist and how they nest), and Google's Rich Results guidance (which defines what fields a given schema type must include to unlock visual rich-result features in search). A piece of markup can be syntactically valid JSON, structurally correct schema.org, and still fail to produce a rich result because it's missing a Google-required field. All three layers matter.

In 2026, validation matters for a third reason: AI search engines have their own implicit requirements. ChatGPT, Perplexity, Gemini, and Google's AI Overviews all weight certain schema signals much more heavily than others. Missing a description, using an anonymous author, leaving out dateModified, or shipping schema with malformed URLs measurably reduces your citation rate in AI responses, even when the schema is technically valid by the old rules. Our validator codifies both the deterministic rules (JSON syntax, required fields, format correctness) and the softer AI-citability rules (description depth, entity connections, freshness signals) as errors versus warnings respectively.

The validator runs entirely in your browser. Paste JSON-LD, click Validate, see results in under 50ms. No round-trip, no server, no rate limit. This makes it fast enough to drop into your development loop: paste, validate, fix, paste again. Generator tools produce valid output by construction — but any time you hand-edit schema, copy it from a CMS, or merge multiple sources, you want to re-validate before pushing.

Ad

Why Validate Before Publishing?

Schema that looks valid can fail in production for reasons you'd never catch by eyeballing the JSON. The most common failure modes we see across schemas we've validated:

  • Missing required fields: Google silently drops rich-result eligibility when a required field is absent — no email, no warning, the result just doesn't appear. Product without offers, Article without publisher, Event without startDate — these all produce clean-looking JSON that Google won't render.
  • Malformed URLs: A URL field set to /image.jpg (relative) or www.example.com/image.jpg (missing protocol) validates as a string but fails as a URL. Most validators catch this; many CMS platforms silently export relative paths.
  • Invalid date formats: A datePublished set to "January 15, 2026" or "2026/01/15" is wrong — must be ISO 8601. Many hand-edited schemas get this wrong; AI engines either reject the date (losing freshness signal) or guess (often wrong).
  • Wrong nested type: A Question whose acceptedAnswer is a string instead of an Answer object. A Review whose author is a string instead of a Person object. These validate as JSON but violate the schema.org contract.
  • Price-currency mismatches: Product offers with a price but no priceCurrency, or with priceCurrency set to "$" or "dollar" instead of the ISO 4217 "USD". Google rejects these silently; AI shopping assistants ignore them.
  • Position gaps in BreadcrumbList: Positions 1, 2, 4 (missing 3) or 1, 3, 2 (out of order). Either breaks Google's breadcrumb trail rendering. Our validator flags both.

Running schema through a validator before every deploy catches all of these. Skipping validation is how mature sites end up with thousands of pages silently ineligible for rich results — the kind of problem that only surfaces when a competitor overtakes you on a query you thought you owned.

What This Validator Checks

JSON syntax

Validates the document parses as JSON. Surfaces the exact error message and approximate position so you can fix it quickly.

@context presence and correctness

Ensures @context is present at the top level and points to schema.org. Warns on non-standard contexts.

@type presence and known values

Every entity must have @type; unknown types get a warning so you know type-specific rules didn't run.

Required fields per type

Each type has its own required-field list derived from Google Rich Results documentation and schema.org base contracts.

URL format

All URL fields (url, image, logo, sameAs, contentUrl, etc.) are checked for absolute http(s) format.

ISO 8601 dates

datePublished, dateModified, uploadDate, startDate, endDate are validated against ISO 8601 patterns — date, date-time, and date-time with timezone.

ISO 8601 durations

totalTime (HowTo) and duration (Video) validated against the PT...H...M...S pattern.

Nested type correctness

Question/Answer, ListItem, HowToStep, Rating, Offer, and PostalAddress are all checked for the correct @type.

@graph flattening

Multi-entity @graph wrappers are transparently handled — each entity is validated with its own path prefix.

Script tag stripping

Paste the full <script type="application/ld+json">...</script> block and the wrapper is stripped before parsing.

AI-citability warnings

Short descriptions, missing sameAs links, missing dateModified, unnamed authors — all flagged as warnings.

Client-side only

Nothing leaves your browser. Safe for confidential schemas (unreleased products, staging content, etc.).

Frequently Asked Questions

How is this different from Google's Rich Results Test?+
Google's Rich Results Test checks whether your markup qualifies for specific Google rich-result visual features (FAQ accordions, product cards, event cards, etc.). Our validator checks that, plus it adds AI-search-specific rules that Google's tool doesn't cover — things like "description too short for reliable AI citation" or "missing sameAs links that would strengthen your Organization entity." Both tools are valuable. The typical workflow: validate here first for fast iteration, then run the final version through Google's Rich Results Test to confirm rich-result eligibility. Our validator works instantly in your browser with no network round-trip; Google's tool requires a public URL and a few seconds to fetch.
Does the validator cover every schema.org type?+
It deeply validates the 10 schema types our generators support: FAQPage, Article (and subtypes: NewsArticle, BlogPosting, TechArticle), Product, LocalBusiness (and 30+ subtypes: Restaurant, Store, Dentist, Hotel, etc.), HowTo, Organization (and subtypes: NGO, Corporation, NewsMediaOrganization, etc.), Review, Event (and subtypes: MusicEvent, SportsEvent, etc.), BreadcrumbList, and VideoObject. For less common types (Recipe, Course, JobPosting, etc.) the validator runs structural checks — JSON syntax, @context presence, @type validity, URL and date format checks — but doesn't enforce type-specific required fields. Expanding coverage is on the roadmap; if you need a specific type validated let us know.
What counts as an error versus a warning?+
Errors are issues that will prevent your schema from earning a rich result or that violate the schema.org vocabulary contract. Missing a required field, a malformed URL, an invalid date format, using the wrong @type for a nested entity — those are errors. Warnings are improvements that won't block your schema from validating but will measurably improve AI citation rates. A warning might flag a description under 50 characters (technically valid, but AI engines prefer more), a missing dateModified (optional but strongly recommended), or an Organization schema without a logo (works without it, but AI answer cards render better with one). A schema can be perfectly valid and still have warnings — address them when you can, but don't let them block a launch.
Can I paste a full <script> tag?+
Yes. The validator auto-detects and strips a surrounding <script type="application/ld+json">...</script> wrapper before parsing. You can copy-paste the markup exactly as it appears in your page source — with or without the script tag. If you have multiple script tags on one page (which is common — an article might have Article + Organization + BreadcrumbList schemas as separate scripts), validate each one separately. A single @graph wrapper with multiple entities inside also works: the validator extracts each and validates them individually.
The validator says my schema is valid but Google's tool disagrees — why?+
Usually because Google has product-specific guidelines that go beyond schema.org's base vocabulary. Google's tool might require an image of minimum 1200px width for a Product, or require a valid dateModified within the last year for a Top Stories news article. Our validator focuses on schema.org correctness plus well-known Google required-field rules; it doesn't replicate every Google product's edge-case requirements. If Google flags an issue our validator misses, that issue is worth fixing — and it's also worth flagging it to us so we can add the rule to our validator.
Does the validator send my data anywhere?+
The validator runs entirely in your browser. Your pasted markup never leaves your device — there's no network request, no server, no logging. This is safe to use for schemas that reference unreleased products, confidential business data, or staging content. We also expose a /api/validate HTTP endpoint for programmatic use in CI pipelines, but the in-browser tool on this page is pure client-side. Open DevTools Network tab if you want to confirm for yourself.
What if my schema has multiple entities in a @graph?+
The validator handles @graph transparently. It flattens the graph into individual entities and validates each one against its own type rules. You'll see errors grouped by entity path — $[0], $[1], $[2] — so you can tell which entity each issue belongs to. This is the correct pattern for modern schema markup: a single script tag containing an @graph array with WebSite, WebPage, Organization, BreadcrumbList, and a primary entity (Article, Product, etc.) all cross-referencing each other via @id. Our validator's path-prefixed errors make multi-entity debugging straightforward.
Can I automate validation in CI?+
Yes. The validator is a plain Node-compatible function (lib/validation/validator.ts), and the /api/validate route wraps it in a standard HTTP POST endpoint accepting {schema: string} and returning {valid, errors, warnings, detectedTypes}. You can call the route from your CI pipeline, or import the function directly into a test script. A common pattern: a CI step that fetches a sample of key URLs, extracts their JSON-LD, and pipes each one through validateSchema() — failing the build if any return errors. This catches regressions before they hit production, which matters because stale schema is a silent killer of AI visibility.

Need to Generate Schema from Scratch?

Ad