How to Test Your Schema Markup (Complete Guide)

You've added schema markup to your site. But how do you know it's actually working?

Testing your structured data is the step most people skip — and the reason most schema markup never triggers rich results. Invalid JSON, missing required fields, or subtle formatting errors can silently prevent Google from using your markup.

This guide covers everything you need to know about testing schema markup, from quick validation checks to comprehensive audits.

Why testing schema markup matters

Google ignores invalid structured data. There's no error message in search results, no notification in Search Console (unless it's a critical issue), and no way to tell from the SERP that your markup isn't working.

Common issues that prevent rich results:

• Missing required fields (like image on Article or offers on Product)
• Invalid JSON syntax (trailing commas, unescaped quotes)
• Wrong @context URL (using http instead of https)
• Nested objects missing their own @type
• Array fields containing a single object instead of an array

The only way to catch these issues is to validate your markup before and after deployment.

Method 1: Validate a live URL

The fastest way to check your schema markup is to validate the live URL. This tests exactly what Google sees when it crawls your page.

Enter your page URL, and the validator extracts all JSON-LD blocks from the page, checks each one against Schema.org requirements and Google's rich result guidelines, and shows you errors, warnings, and a completeness score.

This method catches issues that code-only validation misses:

• JSON-LD blocks that aren't rendering (template errors)
• Multiple schemas conflicting with each other
• Schemas injected by plugins that override your custom markup

Method 2: Validate JSON-LD code

If you're writing schema markup before deploying it, validate the raw JSON-LD first. This catches syntax errors and missing fields before they reach production.

Use the "Validate Code" tab in our Schema Validator to paste raw JSON-LD. It handles single objects, arrays, and @graph containers.

Method 3: Google's Rich Results Test

Google's Rich Results Test is the official tool for checking whether your page qualifies for rich results. It's useful as a final check, but it only validates against Google's subset of Schema.org — not the full specification.

Limitations:

• Only checks rich result eligibility, not completeness
• Doesn't show a completeness score
• Doesn't validate schema types that don't have rich results (like Service or Person)
• Can be slow for pages with many schemas

Use it alongside our validator for the most comprehensive check.

Method 4: Google Search Console

Search Console's Enhancements report shows structured data issues that Google has found while crawling your site. This is the most authoritative source for understanding how Google interprets your markup.

The downside: it only reports issues after Google has crawled the page, which can take days or weeks. It's not a replacement for pre-deployment validation.

What to check in your schema markup

Required vs. recommended fields

Every schema type has required and recommended fields. Required fields must be present for the schema to be valid. Recommended fields improve your chances of getting rich results.

For example, Article schema requires:

• headline
• image
• datePublished
• author (with name)

And recommends:

• dateModified
• publisher
• description
• mainEntityOfPage

Our validator scores completeness based on both required and recommended fields, weighted so required fields count more.

JSON syntax

Common JSON errors that break schema markup:

// Trailing comma (invalid)
{
  "@type": "Article",
  "headline": "My Article",
}

// Unescaped quotes (invalid)
{
  "@type": "Article",
  "headline": "She said "hello""
}

// Single quotes (invalid)
{
  '@type': 'Article',
  'headline': 'My Article'
}

@context and @type

Every JSON-LD block needs:

{
  "@context": "https://schema.org",
  "@type": "YourSchemaType"
}

Use https://schema.org (not http://). While Google accepts both, https is the canonical form.

Nested objects

When a property expects an object (like author on Article), the nested object should include its own @type:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "author": {
    "@type": "Person",
    "name": "Jane Smith"
  }
}

Testing schema markup at scale

Validating individual URLs works for small sites. For larger sites (50+ pages), you need automated validation.

Schema Pilot scans your entire sitemap, generates valid JSON-LD for every page, validates it automatically, and serves it via a lightweight embed script. No manual testing needed — every page gets valid, complete schema markup by default.

Common schema markup errors and fixes

Next steps

1. Validate your site now with our free tool
2. Fix any errors and warnings
3. Re-validate after deployment
4. Monitor Search Console for ongoing issues

Schema markup is only useful if it's valid. Make validation part of your deployment process, and you'll consistently qualify for rich results.