How to Test and Check Schema Markup

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 can still contain invalid JSON, misleading claims or missing feature-specific fields. Test syntax, vocabulary and search eligibility separately. An error does not establish that an AI service will exclude the page.

This guide walks through how to test and check 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 JSON can prevent a block from being parsed. A feature-specific error can prevent that feature from being eligible, while misleading markup may violate search policies. These are different issues, not evidence that every schema mistake harms rankings.

Google stopped showing FAQ rich results on May 7, 2026. FAQPage remains a Schema.org type, but does not create a current Google FAQ search feature. See Google’s May 2026 documentation update. Google also says special AI schema is unnecessary. Keep visible FAQs useful for readers and measure citation observations separately.

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 checks markup against the Schema.org vocabulary, the generic half of what Google’s old Structured Data Testing Tool did.

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: currently supported types such as Article, Product and Recipe; consult the current search gallery instead of relying on a fixed count.

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 (depending on the particular product, recipe or other supported feature).

3. Google Search Console (for ongoing monitoring)

Google Search Console has a separate report for each supported rich result type it finds on your site, under Enhancements (product snippets and merchant listings sit under Shopping). Each report shows:

• Valid and invalid items, counted as structured data items rather than pages
• The issues that make items invalid, with example URLs
• Trends over time, so you can see whether a fix is working

The reports show a sample of detected items, not a full inventory, and only cover types Google can show as rich results. Article and Organization markup, for example, have no report of their own. Use the URL Inspection tool to check a URL the report does not list (Google’s rich result report documentation, checked 1 November 2026).

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).

What replaced Google’s Structured Data Testing Tool?

Google announced on 15 December 2020 that it would retire the Structured Data Testing Tool, the name its Rich Snippet Testing Tool took in 2012. Its job was split in two: Google-specific checks went to the Rich Results Test, and the generic schema.org checks moved to the Schema Markup Validator, which schema.org launched in May 2021. Since 9 August 2021 the old address redirects to a page that helps you pick between the two.

For a quick first pass on a public URL or pasted JSON-LD, use our Schema Markup Validator, then confirm in the official tool that matches your goal. Dates checked 30 October 2026.

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

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 they can make the item eligible for a fuller rich result.

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.

Fixing syntax here is quicker than tracing a broken rich result after the page is live.

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 see how Google reads your markup across the site, from a sample of the items it detected.

How to do it:

1. Go to Google Search Console
2. Navigate to Enhancements in the left sidebar
3. Open each rich result report listed (for example Breadcrumbs, Review snippets or Videos). A report appears only when Google finds valid markup of a supported type. Product snippets and merchant listings sit under Shopping instead
4. Review the valid and invalid item counts
5. Click into any issue to see example URLs, then check a URL the report does not list with URL Inspection

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.
• Critical vs. non-critical issues. A critical issue makes the item invalid, so it cannot appear as a rich result. A non-critical issue leaves the item valid but missing a recommended property.

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: Requirements belong to the specific search feature, not universally to every Schema.org type. Google’s Article documentation lists recommended properties and no required ones. Check the feature and distinguish errors from optional recommendations.

The fix: Check the Schema.org vocabulary for appropriate properties and the Google feature documentation for required and recommended fields. Article properties are recommended, including image and publication date.

{
"@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 leave dateModified stale. A correct date describes a real revision; it is not a guaranteed freshness or citation boost.

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

Appropriate type: Article or BlogPosting, with accurate recommended fields such as headline, datePublished, author and image.

Common issues:

• Missing a useful recommended image property
• author as a plain string instead of a Person object with name and optionally url
• Missing dateModified when content has been updated
• FAQPage is optional for visible FAQs; it does not create a Google FAQ rich result or a proven AI citation benefit.

Service pages

Appropriate type: Service with an accurate provider; this does not create a dedicated Google Service rich result.

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

Feature-specific type: Product. Requirements differ for product snippets and merchant listings; verify the current documentation for the feature you want.

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 (include only accurate, eligible reviews; display is not guaranteed)

Local business pages

Appropriate type: LocalBusiness or a more specific subtype; distinguish required fields from recommended contact details in Google’s current guide.

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