Schema Markup Validator

What this schema markup validator checks

Paste JSON-LD or enter a URL, and the validator does three things. It parses every <script type="application/ld+json"> block and reports JSON syntax errors with the line, the column and the likely cause. It checks that each item has a schema.org @context and a sensible @type. And for the types Google shows rich results for, it checks the properties Google lists as required and recommended, plus value formats like dates, prices, currency codes and rating ranges.

A missing required property is an error: Google won't consider the item for that rich result. A missing recommended property is a warning: the item can still qualify, but you're giving Google less to work with.

What schema markup is

Schema markup, or structured data, is a machine-readable description of what a page is about: this page is a product that costs $39.99 and is in stock, this is a recipe that takes 45 minutes, this is a job posting in Denver. The vocabulary comes from schema.org. Search engines use it to understand a page and, for some types, to show rich results such as review stars, prices, breadcrumbs or event dates. For a longer look at why it's worth doing, see what makes schema markup so valuable.

JSON-LD vs Microdata vs RDFa

There are three ways to put schema.org data in a page. Google supports all three and recommends JSON-LD because it's the easiest to add and maintain.

This tool validates JSON-LD only. It detects Microdata and RDFa and lists their types, so you'll know they're there.

How to validate structured data

Google retired its Structured Data Testing Tool. The generic part moved to schema.org as the Schema Markup Validator, and Google's own checks moved to the Rich Results Test. Each tool answers a different question:

• This tool reads the raw HTML, explains JSON syntax errors in plain terms, and checks Google's documented properties for common rich result types. It doesn't run JavaScript.
• Schema Markup Validator (validator.schema.org) checks any schema.org markup in all three formats against the vocabulary. It doesn't tell you anything about Google rich results.
• Rich Results Test renders the page like Googlebot, JavaScript included, and shows which rich results the page is eligible for. Use it to confirm before you ship.
• Search Console rich result reports show errors and valid items across your site after Google has crawled it.

Required vs recommended properties

Each rich result type in Google's documentation has a table of required and recommended properties. Some types have no required properties at all. Article and Organization, for example, only have recommended ones. Others are strict: an event needs name, startDate and a location with a name and address, and a video needs name, thumbnailUrl and uploadDate. Google's advice is to add fewer recommended properties that are complete and accurate rather than every property with poor data.

Why valid markup may still not get rich results

• Rich results aren't guaranteed. Valid markup makes a page eligible. Google decides whether to show a rich result.
• The markup has to match the page. Google's structured data guidelines require the data to describe content visible to users. Hidden or misleading markup can lead to a manual action.
• The feature may be gone. Google stopped showing how-to rich results in 2023, removed the sitelinks search box in November 2024, and deprecated FAQ rich results in May 2026 after limiting them to government and health sites in 2023.
• Self-serving reviews don't qualify. A business that marks up reviews about itself on its own site isn't eligible for star snippets.

Common JSON-LD errors and how to fix them

Trailing commas and comments

JavaScript tolerates both. JSON doesn't, and one stray comma makes the whole block unreadable.

// Broken
{
  "@type": "Product",
  "name": "Trail Shoe", // model 2
}

// Fixed
{
  "@type": "Product",
  "name": "Trail Shoe"
}

Unescaped quotes and HTML entities

A double quote inside a string ends the string early. The opposite mistake happens when a template HTML-escapes the JSON: browsers don't decode entities inside <script>, so " stays literal.

// Broken
"name": "The "Best" Trail Shoe"
{"@type": "Product"}

// Fixed
"name": "The \"Best\" Trail Shoe"
{"@type": "Product"}

Several objects in one block

Two objects placed one after another aren't valid JSON. Wrap them in an array, or use @graph and link them with @id.

{
  "@context": "https://schema.org",
  "@graph": [
    {"@type": "Organization", "@id": "https://example.com/#org", "name": "Example Co"},
    {"@type": "WebSite", "name": "Example", "url": "https://example.com/",
     "publisher": {"@id": "https://example.com/#org"}}
  ]
}

Values in the wrong format

Prices are numbers with no currency symbol, currencies are ISO 4217 codes, and dates are ISO 8601. A rating outside the scale is an error; if you rate out of 10, say so with bestRating.

// Broken
"price": "$1,299", "priceCurrency": "$", "startDate": "Oct 3, 2026 7pm",
"ratingValue": 8.5

// Fixed
"price": "1299.00", "priceCurrency": "USD", "startDate": "2026-10-03T19:00-05:00",
"ratingValue": 8.5, "bestRating": 10

Type names are case-sensitive too: "@type": "product" doesn't match Product. For more examples, read structured data errors that kill rich results.

Schema added with JavaScript

Google can read JSON-LD that JavaScript injects, such as markup from a tag manager or a CMS widget, because it renders pages before indexing. Tools that read raw HTML, including this one, won't see it. If this tool finds nothing but you know your site adds schema, run the Rich Results Test, which renders the page. Server-rendered JSON-LD is still the safer choice: every crawler sees it, and it doesn't depend on a script loading.

Checking structured data across a whole site

A validator checks one page. Schema usually comes from templates, so one broken template breaks thousands of pages at once. bseoa crawls your whole site from your own computer and flags every page whose JSON-LD doesn't parse, so you can find the template behind the error. Add --spa to render JavaScript before auditing:

black-seo-analyzer --url-to-begin-crawl https://example.com --spa --output-type csv --output-file crawl.csv