Schema Markup Validator

What this schema validator checks

Every check falls into one of three layers, and the report groups problems by how serious they are.

1. Syntax

JSON-LD that doesn't parse is ignored by Google, so parse errors come first, with the block, line, and column. The validator also flags top-level items with no @context or no @type.

2. The schema.org vocabulary (version 30.1)

• Types and properties that don't exist, with a suggestion (LocalBussiness → LocalBusiness, adress → address).
• Properties used on a type they don't belong to, taking inheritance into account (a Restaurant can use every LocalBusiness, Organization, and Place property).
• Values in the wrong form: an object whose @type isn't what the property expects, dates and durations that aren't ISO 8601, prices with currency symbols, currency codes that aren't ISO 4217, ratings outside their scale, enumeration URLs that don't exist, and repeated keys.
• Superseded terms (with the replacement) and pending terms that may still change.
• @id references that point to an item the markup doesn't define.

3. Google rich result requirements

For 28 Google Search features, the validator checks the required and recommended properties from Google's structured data documentation (last verified 2026-10-07), including "one of" rules. For example, a product snippet needs a review, an aggregate rating, or an offer. Each detected item is marked eligible or not eligible, and the report lists exactly what's missing.

Features checked: Article, Breadcrumb, Dataset, Discussion forum, Education Q&A, Employer aggregate rating, Event, Image metadata, Job posting, Local business, Math solver, Movie carousel, Organization, Profile page, Q&A, Recipe, Review snippet, Product snippet, Merchant listing, Product variants, Software app, Vacation rental, Video, Course list, Loyalty program, Return policy, Shipping policy, Speakable.

How it compares with Google's Rich Results Test and the Schema.org Validator

Use this validator to find and fix problems quickly, then run the published URL through Google's Rich Results Test before you rely on a rich result. Google's test is the final word on what Google can show.

Reading the report

Errors

Problems that stop Google or other parsers from using the markup: syntax errors, types and properties that don't exist, and missing properties that a rich result requires. Fix these first.

Warnings

The markup works, but something is off or incomplete: a value in the wrong form, a superseded term, or recommended properties that would make the result richer. Add the ones that are true and visible on the page.

Notes

Information, not problems: a retired rich result, a pending schema.org term, or an @id that another part of the page may define.

Eligible / Not eligible

For each Google feature found, whether every required property is present. Eligible means Google can show the rich result, not that it will.

Retired / Limited

The type is valid schema.org, but Google no longer shows that rich result, is phasing it out, or only shows it in a narrow case (such as English-language news for Speakable).

Common mistakes and how to fix them

"name": "Trail Shoe",
"sku": "TS-1",
}

"name": "Trail Shoe",
"sku": "TS-1"
}

"price": "$1,299.99"

"price": "1299.99",
"priceCurrency": "USD"

"startDate": "10/31/2026 7pm"

"startDate": "2026-10-31T19:00:00-04:00"

"@type": "LocalBussiness",
"adress": { ... }

"@type": "LocalBusiness",
"address": { ... }

"ratingValue": "7"

"ratingValue": "7",
"bestRating": "10"

One mistake no validator can catch: Google's guidelines say "Don't mark up content that is not visible to readers of the page." Every fact in your markup (prices, ratings, dates, addresses) should also appear on the page itself.

Search Console's "Unparsable structured data" errors, explained

If Search Console reports unparsable structured data, Google couldn't read the markup at all, so nothing in that block counts. These are the most common error types in Google's report documentation (the full list also covers rarer Unicode and escape-sequence errors), and how this validator shows each one.

Invalid JSON document

The JSON has a top-level syntax error. Here: The error under Search Console's name, with the block, line, and column.

Parsing error: Missing ',' or '}'

A comma between properties or a closing brace is missing. Here: The same name, with the line and column where parsing stopped. Check the line above too: the missing comma is usually at the end of the previous property.

Parsing error: Missing ':'

A colon is missing between a property name and its value. Here: The line and column of the property.

Parsing error: Missing '}' or object member name

A closing brace or a property name is missing, often because of a trailing comma. Here: The same name, flagged as likely a trailing comma, with its line and column.

Parsing error: Missing ',' or ']' in array declaration

An array is missing a comma between items or its closing bracket. Here: The line and column inside the array.

Bad escape sequence in string

A backslash is followed by a character JSON doesn't allow, such as \q. Quotes inside a value need \". Here: A syntax error at the escape.

Incorrect value type

A field has the wrong kind of value, for example a string where a number or array was expected. Here: Value checks: prices with currency symbols, currency codes that aren't ISO 4217, ratings outside their scale, dates, durations, URLs, enumeration values, and objects whose @type isn't what the property expects.

Duplicate unique property

A unique property is defined twice, such as two @context values. Here: Every repeated key with its line. A repeated @context, @type, or @id is an error; any other repeated key is a warning, because only the last value survives.

Invalid top level element

A top-level item in the JSON-LD is invalid. Here: Missing @context and missing @type on top-level items.

Reference to nonexistent item

A microdata itemref points to an id that doesn't exist on the page. Here: An error naming the itemref id that has no matching element. JSON-LD @id references that point to nothing are listed as notes.

After you fix a parsing error, Google notes that "you might trigger additional warnings or errors that were hidden because the item could not be parsed at all." That's why this validator runs the vocabulary and Google checks as soon as the syntax is clean.

Rich results Google no longer shows

Google retires rich results from time to time. The markup stays valid schema.org, so the validator reports these as notes rather than errors. Keep the markup if it describes the page accurately; just don't expect the rich result.

JSON-LD, microdata, and RDFa

All three formats describe the same schema.org data in different ways. JSON-LD is a block of JSON in a <script type="application/ld+json"> tag, separate from your visible HTML. Microdata and RDFa add attributes (itemprop, property) to the HTML elements that show the content.

Google says it "recommends using JSON-LD for structured data if your site's setup allows it, as it's the easiest solution for website owners to implement and maintain at scale." If you're starting fresh, use JSON-LD. The schema generators on this site all produce it.

FAQ

Is this the same as Google's Rich Results Test?

No. Google's Rich Results Test is the official check and it renders JavaScript, but it only reports on the rich results Google supports. This validator also checks every type and property against the schema.org vocabulary, explains each fix, and works on pasted code. Use it to find and fix problems, then confirm the published URL in Google's test.

If my markup is valid, will Google show a rich result?

Not necessarily. Google says it "does not guarantee that your structured data will show up in search results, even if your page is marked up correctly according to the Rich Results Test." Valid markup makes a page eligible. Content quality, policy compliance, and Google's own choices decide whether the rich result appears.

Can it check structured data that JavaScript adds to the page?

In URL mode it reads the HTML your server sends, so markup injected by JavaScript won't appear. Google can read JSON-LD that JavaScript adds when it renders the page. To check it here, open the page in Chrome, copy the rendered HTML from DevTools (Elements panel, right-click the html element, Copy › Copy outerHTML), and paste it into the code box.

Why is my FAQPage or HowTo markup labeled retired?

Google stopped showing FAQ rich results on May 7, 2026, and removed How-to rich results in 2023. FAQPage and HowTo are still valid schema.org types, so the validator reports them as a note, not an error. Keep the markup if it accurately describes the page; just don't expect that rich result.

Which formats does it support?

JSON-LD (raw, or inside script tags), microdata (itemscope, itemtype, itemprop, itemref, itemid), and RDFa Lite (vocab, typeof, property, resource, prefix). Google recommends JSON-LD when your setup allows it.

Do you save the code or pages I check?

Validation doesn't store your input: the code or page is checked and the report goes back to your browser. If you click Fix with AI, your code and the list of issues are sent to the AI generator so it can write a corrected version.