How to Test Schema Markup: 3 Free Validators and When to Use Each

You added FAQ schema to a page, pasted it into a validator, saw a green tick, and shipped it. Three weeks later there's still no rich result, and you don't know why.

That's usually because the tool answered a different question from the one you asked. "Is this valid schema.org?" and "Will Google show a rich result?" are not the same test. This guide explains how to test schema markup properly: which free tool answers which question, the errors that most often break things, and a four-step workflow.

Three questions, three tools

You need all three at different moments. The most common mistake is using only the first and assuming it covers the second.

Tool 1: Schema Markup Validator

The Schema Markup Validator replaced Google's old Structured Data Testing Tool and is now run by schema.org. It checks that your JSON-LD, Microdata or RDFa parses correctly and uses real schema.org types and properties.

Use it when: you're writing markup for a type Google doesn't turn into rich results (like Organization details or Person), or you want a quick syntax check.

It won't tell you: whether Google will show anything special for the page.

Tool 2: Google's Rich Results Test

The Rich Results Test answers the narrower, more useful question: which Google rich results is this page eligible for? It only evaluates the types Google supports and flags missing required properties that schema.org itself treats as optional.

Use it when: you're adding markup for products, reviews, recipes, events, job postings, breadcrumbs or any other rich-result type.

Two things to know:

• "Eligible" isn't "guaranteed". Even valid, eligible markup may not produce a rich result. Google decides per query.
• It renders the page. If your schema is injected by JavaScript, the Rich Results Test will see it. A raw-HTML checker may not.

Tool 3: Search Console enhancement reports

Once markup is live, Search Console shows a report for each detected type, with counts of valid items, items with warnings and invalid items. This is how you catch the template change that quietly broke product schema on 3,000 pages.

Use it when: after every deployment that touches templates, and monthly as a routine check.

Testing schema that JavaScript adds

Many sites inject structured data with JavaScript: a tag manager, a React component, a plugin that runs in the browser. That's allowed, but it adds a way for things to go wrong.

• Test the live, rendered page. The Rich Results Test renders JavaScript the way Google does, so test the URL rather than pasting source code.
• View the rendered HTML. In the Rich Results Test, open the tested page's HTML to confirm your JSON-LD is actually in it.
• Watch for timing. Markup added after a user interaction, like a click or scroll, may never be seen.

If you can, output structured data on the server instead. It removes a whole category of bugs.

How long until rich results appear?

After Google recrawls the page, eligible rich results can start showing within days, but there's no fixed timeline and no guarantee. Two things speed up the first step: request indexing for the page in Search Console's URL Inspection tool, and make sure the page is in your sitemap. If the Rich Results Test passes, the enhancement report shows the item as valid, and there's still no rich result after a few weeks, Google has simply chosen not to show one for those queries. That's its decision, not an error in your markup.

The 6 errors that most often break rich results

1. Missing required property. For example, Product markup with no offers, review or aggregateRating. The Rich Results Test lists exactly which property is missing.
2. Markup that doesn't match visible content. Google's structured data policies require the marked-up information to be visible to users. FAQ answers that only exist in the JSON-LD break this rule.
3. Invalid JSON. A trailing comma or an unescaped quote breaks the whole block. Paste it into the JSON-LD Playground to find the exact line.
4. Wrong value types. A price written as "$19" instead of 19 with a separate currency, or dates not in ISO 8601 format.
5. Duplicate or conflicting blocks. A plugin and a theme both outputting Organization with different names. Pick one source.
6. Marking up the wrong page. Review markup for your own business on your homepage, for example, isn't eligible for review stars.

A valid example, for reference

A minimal FAQ block that passes both validators:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does an SEO audit take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "A single-page audit takes under a minute. A full site audit depends on page count."
      }
    }
  ]
}

The question and answer text must also appear on the page itself. If you're new to the vocabulary, schema.org's own getting started guide is short and clear.

A 4-step workflow for testing schema markup

1. Before publishing: paste the code into the Rich Results Test (code mode) to confirm eligibility and required properties.
2. After publishing: run the live URL through the Rich Results Test. This catches anything your CMS or JavaScript changed.
3. After one to two weeks: check the matching Search Console enhancement report for errors across all pages using that template.
4. Monthly: spot-check key templates. A quick pass with DidYouSEO's free schema checker shows which types a page has and flags common problems in one view.

Common mistakes

• Treating a schema.org validator pass as a rich-result pass. They're different tests, as above.
• Testing one page and assuming the template is fine. Products with no reviews, or events with no end date, often fail where the sample page passed.
• Adding every schema type you can find. Markup that doesn't describe the page adds risk without benefit. Mark up what's actually there.
• Ignoring warnings. Warnings don't block eligibility, but recommended properties often decide whether the rich result appears at all.

Structured data also helps AI systems understand a page, beyond rich results. We cover that in schema markup for AI citability.