How to Test and Validate Schema Markup: A Complete Guide

You’ve added schema markup to your website. The JSON-LD looks right. You published the page.

But does it actually work?

Schema markup that looks correct isn’t always correct. A trailing comma, a missing required property, a date in the wrong format: any of these can break your structured data completely. Google will silently ignore it. Rich results won’t appear. AI systems will skip your page for citation. And you won’t know unless you test.

This guide walks through how to validate schema markup at every stage: before publishing, after publishing, and on an ongoing basis. We cover the tools, the workflow, the most common errors, and how to fix them.

If you’re not sure what schema markup is or which types your website needs, start with our guide on what schema markup is and why it matters for SEO.

Why Testing Schema Markup Matters

Invalid schema is worse than no schema. Here’s why.

When Google crawls your page and finds broken structured data, it doesn’t just skip the schema. It flags it as an error in Search Console. Pages with schema errors can lose rich result eligibility until the issues are fixed, even if the same page had working rich results before.

For AI search, the stakes are even higher. AI systems like Google AI Overviews and ChatGPT Search use structured data to understand, verify, and cite content. Invalid schema means AI can’t confidently parse your page, which reduces your chances of being cited. We covered this in depth in our article on how schema markup helps your business earn AI citations.

Testing takes 30 seconds. Not testing can cost you months of lost visibility.

The Three Tools You Need

There’s no single validation tool that catches everything. Each tool checks different things. Here’s what to use and when:

1. Schema Markup Validator (for comprehensive syntax checks)

A schema markup validator checks your structured data against the full Schema.org specification. It catches syntax errors, missing properties, wrong data types, and structural issues across all schema types.

When to use it:

• During development (paste code snippets)
• On staging or preview URLs before launch
• After making any changes to schema code
• When you want to check all schema types, not just the ones Google uses for rich results

Our Schema Markup Validator is a fast diagnostic: give it a public live URL to extract JSON-LD, or paste JSON-LD directly for private, browser-side checking. Use the official Schema.org validator for vocabulary conformance and Google’s Rich Results Test for Google-specific eligibility; no single tool covers all three jobs.

The Schema.org Markup Validator is the Schema.org community’s official vocabulary validator. It replaced Google’s Structured Data Testing Tool in 2021 and checks markup against the Schema.org vocabulary.

2. Google Rich Results Test (for Google-specific eligibility)

Google Rich Results Test tells you whether your schema qualifies for rich results in Google Search. It only validates schema types that Google uses for enhanced search features: Article, FAQ, Product, Recipe, Event, LocalBusiness, and about 30 others.

When to use it:

• After publishing a page (test the live URL)
• To verify that Google can render your JavaScript-injected schema
• To see a preview of how your rich result will look in search
• When you specifically care about Google rich result eligibility

Key difference: A schema markup validator checks against the full Schema.org specification. Google Rich Results Test checks against Google’s subset and Google’s specific requirements. Your schema can be valid according to Schema.org but still fail Google’s rich results requirements if it’s missing properties Google considers essential (like image on Article).

3. Google Search Console (for ongoing monitoring)

Google Search Console reports structured data health for your entire site over time. Under the Enhancements section, Google shows:

• Which schema types it detected across your site
• How many pages are valid, have warnings, or have errors
• Specific error messages for each affected URL
• Trends over time (are errors increasing or decreasing?)

When to use it:

• Weekly check for new errors
• After any CMS update, plugin update, or site redesign
• To track whether your schema fixes are working
• To catch silent schema breaks you didn’t notice

Tool comparison at a glance

Other tools worth knowing: Bing Markup Validator validates schema for Bing’s search features. JSON-LD Playground checks raw JSON-LD syntax and structure (useful for debugging complex nesting).

The 4-Step Validation Workflow

Testing schema isn’t a one-time thing. It’s a workflow with four stages: validate before publishing, test the live page, monitor in Search Console, and audit quarterly.

Step 1: Validate your code before publishing

Before adding schema to a live page, test the code itself.

How to do it:

1. Copy your entire JSON-LD block (including the <script type="application/ld+json"> tags)
2. Paste it into a schema markup validator using the code snippet input
3. Fix every error until you get zero errors
4. Review warnings and address the ones that affect rich results eligibility or AI understanding

What to look for:

• Errors (red): broken syntax, missing required properties, invalid types. These must be fixed.
• Warnings (yellow): missing recommended properties. Not required, but adding them improves your chances of getting rich results and AI citations.

Pro tip: If you’re building schema for multiple page types (articles, services, products), create and validate a template for each type. Then you only need to validate once per template, not once per page.

This step catches 90% of issues before they reach your live site.

Step 2: Test the live URL after publishing

Code that validates in isolation can still fail on a live page. JavaScript rendering issues, caching problems, CMS modifications, or conflicting plugins can all alter or break your schema between your code editor and the browser.

How to do it:

1. Publish the page
2. Wait 2-5 minutes for caching to clear
3. Run the live URL through Google Rich Results Test
4. Also run it through a schema markup validator to catch issues the Rich Results Test doesn’t flag

What to look for:

• Does the page show all the schema types you added?
• Are there any types appearing that you didn’t add? (Some CMS plugins inject their own schema, which can conflict with yours)
• Does the Rich Results Test show your page as “eligible” for the rich result types you’re targeting?

Common issue: You added Article schema manually, but your WordPress SEO plugin also injects Article schema. Now Google sees two conflicting Article schemas. Testing the live URL catches this.

Step 3: Monitor in Google Search Console

Search Console is where you find out how Google actually interprets your schema across your entire site.

How to do it:

1. Go to Google Search Console
2. Navigate to Enhancements in the left sidebar
3. Check each schema type listed (Articles, FAQ, Breadcrumbs, etc.)
4. Review the Valid / Warning / Error counts
5. Click into any errors to see affected URLs and specific issues

What to look for:

• New errors appearing. This often means a plugin update, CMS change, or template modification broke something.
• Error trends. Are errors increasing over time? That suggests a systematic issue, not a one-off mistake.
• Warnings vs. errors. Errors prevent rich results. Warnings don’t prevent them but indicate opportunities for improvement.

Set up notifications: In Search Console Settings, enable email alerts for structured data issues. This way you catch breaks immediately instead of discovering them weeks later.

Step 4: Audit quarterly

Schema breaks silently. A CMS update removes a property. A plugin conflict adds duplicate types. A content edit creates a mismatch between schema and visible content. You won’t notice unless you check.

How to do it:

1. Pick 10-15 URLs across your site (homepage, about page, 3-4 blog posts, service pages, any pages with complex schema)
2. Run each through a schema markup validator
3. Compare the results against what you expect to be on each page
4. Check for deprecated properties or types that Schema.org has updated
5. Verify that dateModified is current on pages you’ve updated

Why quarterly? Schema.org updates its vocabulary regularly. Google’s rich result requirements evolve. Your site changes over time. A quarterly check prevents small issues from becoming site-wide problems.

The 10 Most Common Schema Errors (and How to Fix Them)

These are the errors we see most often when validating client websites. Understanding them saves you time during validation.

1. Missing required properties

The error: “Missing required property: image” or “Field ‘name’ is required”

Why it happens: Every schema type has mandatory fields. Article requires headline, datePublished, author, and image. Product requires name. Organization requires name and url. Skipping any of them invalidates the schema.

The fix: Check the Schema.org documentation for your schema type’s required properties. For Google-specific requirements, check Google’s structured data documentation for the type you’re implementing.

{
"@type": "Article",
"headline": "Your Article Title",
"datePublished": "2026-04-02",
"author": {
  "@type": "Person",
  "name": "Author Name"
},
"image": "https://yoursite.com/images/article-image.jpg"
}

2. Invalid JSON syntax

The error: “Parse error” or “Unexpected token”

Why it happens: JSON is strict. A trailing comma after the last property, an unclosed bracket, a missing quote, or using single quotes instead of double quotes will break the entire block.

The fix: Use a JSON linter (like jsonlint.com) to find the exact line with the syntax error. Common culprits: trailing commas, missing closing braces, unescaped special characters in text values.

{
"name": "Web Aloha",
"url": "https://webaloha.co",  ← trailing comma
}

{
"name": "Web Aloha",
"url": "https://webaloha.co"
}

3. Wrong data types

The error: “Expected Number but got String” or “Invalid date format”

Why it happens: Schema properties expect specific data types. price should be a number ("19.99"), not text ("$19.99"). datePublished must follow ISO 8601 format (2026-04-02), not a human-readable format (April 2, 2026).

The fix: Match data types exactly. Prices are numbers without currency symbols. Dates use ISO format. URLs must be complete (not relative paths). Ratings must be numbers within the specified range.

4. Relative URLs instead of absolute

The error: “Invalid URL format” or a URL that doesn’t start with http/https

Why it happens: Your code uses /images/photo.jpg instead of https://yoursite.com/images/photo.jpg. Schema requires absolute URLs for properties like image, url, and logo.

The fix: Always use complete URLs starting with https://. If your site generates schema dynamically, make sure your template prepends the domain.

5. Schema doesn’t match visible content

The error: No validation error, but Google ignores the schema or manually flags it

Why it happens: Your schema says the product costs $29, but the page shows $39. Your Article schema says it was published in 2026, but the visible date says 2024. Google requires schema to accurately represent the content visible to users.

The fix: Audit your schema against the visible page content. Every claim in your schema must be verifiable on the page. This is a Google policy, not just a best practice.

6. Duplicate or conflicting schema

The error: Multiple schema blocks of the same type with different values

Why it happens: Your CMS SEO plugin generates Organization schema, and you also added Organization schema manually. Or multiple plugins each inject their own Article schema. Google sees conflicting information and may ignore both.

The fix: Audit your page source for all application/ld+json script tags. Remove duplicates. If using a plugin for schema, either let the plugin handle it entirely or disable the plugin’s schema and use your own.

7. Missing @context declaration

The error: Schema types not recognized

Why it happens: Every JSON-LD block needs "@context": "https://schema.org" to tell processors which vocabulary you’re using. Without it, the structured data is meaningless.

The fix: Always include the @context property at the top level of your JSON-LD.

8. Deprecated schema types or properties

The error: Warnings about deprecated terms or no rich results despite valid schema

Why it happens: Schema.org evolves. Properties get renamed, types get restructured. Google drops support for certain rich result types. If you’re using old documentation or copy-pasting from outdated tutorials, your schema might use terms that no longer work.

The fix: Check the Schema.org release history for recent changes. Review Google’s search gallery for currently supported rich result types.

9. Incorrect nesting

The error: Properties placed at the wrong level in the schema hierarchy

Why it happens: Schema types have specific structures. An Offer should be nested inside a Product, not at the top level. An author should contain a Person object, not just a text string.

The fix: Follow the Schema.org documentation for your type’s expected structure. Use a validator to check hierarchy. When in doubt, use our Schema Markup Generator which produces correctly nested JSON-LD for 12 schema types.

10. Missing dateModified on updated content

The error: Not a validation error, but a missed opportunity

Why it happens: You update an article but don’t update the dateModified property. Google (and AI systems) can’t tell the content is fresh. For GEO and AI search visibility, freshness signals are a factor in citation decisions.

The fix: Update dateModified every time you meaningfully update a page’s content. Automate this if your CMS supports it.

Schema Validation for Different Page Types

Different pages need different schema, and each type has its own common pitfalls:

Blog posts and articles

Required schema: Article (with headline, datePublished, author, image)

Common issues:

• Missing image property (Google requires this for Article rich results)
• author as a plain string instead of a Person object with name and optionally url
• Missing dateModified when content has been updated
• FAQPage schema missing on posts that have FAQ sections (a big missed opportunity, since FAQ schema is one of the strongest signals for AI citations)

Service pages

Required schema: Service with provider (Organization), optionally OfferCatalog

Common issues:

• Missing provider property linking back to your Organization
• No areaServed for local services
• Vague description that doesn’t match the page content

Product pages

Required schema: Product with name, offers (including price, priceCurrency, availability)

Common issues:

• Price format errors (using “$19.99” instead of “19.99” with separate priceCurrency)
• Missing availability (should use Schema.org enumeration values like https://schema.org/InStock)
• Missing review or aggregateRating (not required, but significantly improves rich result display)

Local business pages

Required schema: LocalBusiness with name, address, telephone

Common issues:

• Address as plain text instead of structured PostalAddress object
• Missing geo (latitude/longitude) which helps Google Maps and local search
• Opening hours in wrong format (should use OpeningHoursSpecification)

When to Validate: Quick Reference

Validation Checklist: Before Every Publish

Use this checklist every time you add or update schema markup on a page:

Next Steps

Schema validation is one piece of a larger structured data strategy. Here’s how everything connects:

• New to schema? Read What Is Schema Markup and Why It Matters for SEO for the fundamentals
• Want AI visibility? Learn How Schema Markup Helps Your Business Earn AI Citations for the AI search angle
• Need to build schema? Use our Schema Markup Generator to create valid JSON-LD for 12 types
• Ready to validate? Run your site through our Schema Markup Validator right now
• Want professional help? Our SEO services and GEO services include full structured data implementation and validation