Free tool

Free schema validator and checker

Enter a page URL or paste JSON-LD to check your schema markup in seconds: whether every block is valid, and whether it has the properties Google requires for rich results. No signup, and nothing is stored.

We fetch the page once and read its JSON-LD. Nothing is stored.

What the result means

How to check schema markup on any page

  1. Enter the page address, or paste the code. Use "Validate a URL" for a live page, or "Paste JSON-LD" to check markup before it goes live.
  2. Read the red, amber and green result. Red is broken or missing a required property, amber is valid with gaps worth filling, green is ready for rich results.
  3. Confirm in Google's Rich Results Test. Once this check is clean, Google's own test tells you which rich results the page is eligible for.

What this schema validator checks

A schema validator (also called a schema checker or structured data validator) checks a page's structured data: the code that tells search engines and AI tools what a page is, such as a local business, a product, an article or an event. This one reads every JSON-LD block on the page and checks two things. First, syntax: does each block parse, and does it declare the schema.org vocabulary? One stray comma makes Google ignore the whole block. Second, required properties: for the rich-result types listed further down this page, is everything Google lists as required actually there?

It reads JSON-LD, the format Google recommends. If the page also uses Microdata or RDFa, the result says so, but those formats aren't validated here; use validator.schema.org for them.

Reading your result

A red result means something is broken or missing a required property, so Google won't show a rich result for it. Amber means the markup is valid but missing recommended properties, which are optional but give a fuller picture. The most common gap on small business sites is simpler than either: no Organization or LocalBusiness markup at all, which is the markup that tells machines who is behind the site.

Common schema errors and how to fix them

  • Invalid JSON. Usually a trailing comma after the last property, an unescaped double quote inside a value, or curly "smart" quotes pasted from a document. Search engines ignore the whole block. Fix the line, then paste the block into "Paste JSON-LD" to re-check it before it goes live.
  • Missing @context. Every block needs "@context": "https://schema.org" so parsers know which vocabulary the types come from.
  • Missing a required property. For example, a LocalBusiness without an address, or a Product with no offers, review or aggregateRating. The result names the property; add it with a real value from the page.
  • A type you expected isn't found. Check the spelling and capitals of @type (it is LocalBusiness, not Localbusiness). If the markup is added by JavaScript after the page loads, this check can't see it, so test that page in Google's Rich Results Test instead.
  • No Organization or LocalBusiness markup. The most common gap on small business sites. Add one block on your homepage with your name, address, phone number and logo, matching your Google Business Profile.

More free checks

Schema is one part of how a page reads to search engines. Check the basics with the meta tag checker and the Open Graph checker, confirm crawlers are allowed in with the robots.txt checker, or browse every free tool. To look at one whole page at once, run the free one-page site audit.

What it doesn't do

This is a fast first check, not Google's final word. It reads the HTML your server sends, so markup injected by JavaScript won't show up here. It doesn't apply Google's content policies either. Once this tool is clean, confirm eligibility in Google's Rich Results Test, and see how the two compare below. For what to add and why, read our structured data guide, the LocalBusiness schema guide and what replaced Google's Structured Data Testing Tool.

Example result

What a result looks like

A real result for a made-up page with three blocks: a complete LocalBusiness (green), a Product with gaps (amber) and a block with a syntax error (red).

https://teaselstone.example/workshops

Some of your structured data is broken or missing required properties.

Syntax

  • Pass: Block 1: valid JSON-LD (4 items)

  • Pass: Block 2: valid JSON-LD (2 items)

  • Problem: Block 3: invalid JSON

    Expected double-quoted property name in JSON at position 143 (line 6 column 1). Search engines ignore the whole block. Common causes: a trailing comma, an unescaped quote, or a smart quote pasted from a document.

Rich result properties

  • Note: Types found: LocalBusiness, PostalAddress, GeoCoordinates, OpeningHoursSpecification, Product, Offer

  • Pass: LocalBusiness: all required properties present

  • Needs attention: Product: valid, but missing recommended "brand", "sku"

    Recommended properties aren't required, but adding them gives search engines and AI tools a fuller picture and can improve how the result looks.

  • Pass: Offer: all required properties present

  • Note: 3 items of other types

    Valid schema.org types with no rich-result requirements that this tool checks. They still help machines understand the page.

The page is invented (Teaselstone Studio is a fictional business and teaselstone.example/workshops is not a real address). The result is what this tool returns for that markup. Green means the required properties are all there. Amber means valid, with recommended properties missing. Red means a required property is missing, so Google won't show a rich result for it. Blue is a note, not a verdict.

Supported types

The types it checks

Each type is checked against the properties Google lists as required, plus the recommended ones that make the markup more useful. Other schema.org types are read and counted, but not judged.

  • LocalBusiness

    Name, address and opening hours for a business that serves customers locally.

    Required:
    name, address
    Recommended:
    telephone, url, openingHoursSpecification, geo, priceRange, image
    Also covers:
    88 subtypes, such as Dentist, Plumber, Restaurant and Store
  • Organization

    Who is behind the site: name, logo and profile links.

    Recommended:
    name, url, logo, sameAs
  • Article

    Blog posts and news articles.

    Recommended:
    headline, image, datePublished, author
    Also checks:
    NewsArticle, BlogPosting
  • Product

    Product pages, including the price and currency on each offer.

    Required:
    name, at least one of offers, review, aggregateRating
    Recommended:
    image, description, brand, sku
    Also checks:
    Offer, AggregateOffer
  • FAQPage

    Question and answer markup. Google now shows FAQ rich results only for well-known government and health sites.

    Required:
    mainEntity
    Also checks:
    Question, Answer
  • BreadcrumbList

    The trail of pages shown under a result. The last crumb may omit its link.

    Required:
    itemListElement
    Also checks:
    ListItem
  • Review and AggregateRating

    Star ratings and individual reviews. A review nested inside a product does not need to name the product again.

    Required:
    itemReviewed, author
    Recommended:
    reviewRating
    Also checks:
    AggregateRating
  • Event

    Dates and venues for events.

    Required:
    name, startDate, location
    Recommended:
    endDate, image, offers, eventStatus
  • Recipe

    Recipe pages.

    Required:
    name, image
    Recommended:
    recipeIngredient, recipeInstructions, totalTime
  • VideoObject

    Videos you host or embed.

    Required:
    name, thumbnailUrl, uploadDate
    Recommended:
    description, duration, contentUrl
  • JobPosting

    Vacancies.

    Required:
    title, description, datePosted, hiringOrganization
    Recommended:
    jobLocation, validThrough
  • WebSite and Person

    Basic identity markup. Checked for recommended properties only.

    Recommended:
    name, url
    Also checks:
    Person
  • HowTo

    Recognised, but Google stopped showing HowTo rich results in 2023, so the tool says so rather than asking for more.

How it compares

How this differs from Google's own tools

Google's Rich Results Test and the Schema Markup Validator are the authorities. This is a quicker first pass to run before them.

This schema validator

Enter a page address or paste code and get plain-English results with no signup. It reads the JSON-LD in the HTML your server sends (or the code you paste), checks the types listed above and tells you what is missing for a rich result. It doesn't validate microdata or RDFa, or apply Google's content policies.

Google's Rich Results Test

The authority on whether a page is eligible for Google's rich results. It renders JavaScript, so it sees markup added after the page loads, and it covers more result types than this tool. Use it for the final answer. Open the Rich Results Test.

validator.schema.org

The Schema Markup Validator checks syntax against the full schema.org vocabulary, for any type and in JSON-LD, microdata or RDFa. It isn't specific to Google, so it won't say which properties Google needs for a rich result. Open validator.schema.org.

A sensible order: run this schema validator first to catch broken syntax and missing properties, then confirm in Google's Rich Results Test before you publish.

This is one check. Your site needs dozens.

The full AuditCrow audit runs this alongside speed, SEO, accessibility, trust and AI readiness, then tells you what to fix first, in plain English.

FAQ

Common questions

Straight answers about what this check does, and doesn't do.

What is a schema validator?

A schema validator reads the structured data (schema markup) on a page and checks it. Is the JSON-LD valid, does it use the schema.org vocabulary, and does each type have the properties Google needs for a rich result? This one reports the answer in plain English, with the fix for anything missing.

How is this different from Google's Rich Results Test and validator.schema.org?

Those two are the authorities, and you should confirm in them. The Rich Results Test renders JavaScript and judges eligibility for Google's rich results. validator.schema.org checks syntax against the whole schema.org vocabulary. This tool is a quicker first pass: give it a URL, or paste your JSON-LD, and it lists what is missing for the common rich result types, in plain English. For a URL it reads only the JSON-LD your server sends, and pasted code is checked in your browser without being sent anywhere.

Is this a replacement for Google's Structured Data Testing Tool?

Google retired the Structured Data Testing Tool and split its job in two: the Rich Results Test (does this page qualify for Google's rich results?) and the Schema Markup Validator (is this valid schema.org?). This tool does the quick version of both for JSON-LD: it checks every block parses and that common types have the properties Google lists as required.

Why does it say no structured data was found when I know I have some?

Two usual reasons. Your markup may be microdata or RDFa rather than JSON-LD (the tool tells you if it spots those), or it may be added by JavaScript after the page loads. This tool reads the HTML your server sends; Google's Rich Results Test renders JavaScript, so use it to confirm.

Does valid schema guarantee a rich result?

No. Valid markup with the required properties makes a page eligible, but Google decides whether to show a rich result. Some types are also restricted: FAQ rich results only appear for well-known government and health sites, and HowTo rich results were withdrawn in 2023.

Which schema should a small business have?

At minimum, Organization or LocalBusiness markup on your homepage, with your name, address, phone number and links to your profiles (sameAs). Add Article markup on blog posts, Product on product pages and BreadcrumbList site-wide if your theme supports it.

Does it check Microdata and RDFa?

No. It validates JSON-LD, the format Google recommends and the one most sites and plugins use. If a page also carries Microdata or RDFa, the result tells you so, but those blocks aren't checked. Use validator.schema.org for them.

Free first audit

Ready to see what's holding your site back?

Run one page through AuditCrow and get a clear, prioritised report on what is standing between your site and the job you need it to do.

One page free · Plain-language fixes · Your first taste of the full platform