---
title: "How to Test and Validate Schema Markup: A Complete Guide"
description: "Learn how to test schema markup step by step. Find errors, fix structured data issues, and validate your JSON-LD before and after publishing. Includes tools comparison and common error fixes."
canonical_url: "https://webaloha.co/how-to-test-schema-markup/"
markdown_url: "https://webaloha.co/how-to-test-schema-markup.md"
date_published: "2026-04-02T00:00:00.000Z"
date_modified: "2026-04-02T00:00:00.000Z"
author: "Lucky Oleg"
---
# How to Test and Validate Schema Markup: A Complete Guide

Author: [Lucky Oleg](https://webaloha.co/authors/lucky-oleg/) | Published Apr 2, 2026

![How to Test and Validate Schema Markup: A Complete Guide](https://webaloha.co/_astro/blog-how-to-test-schema.Dk6gLJiH_4XMTY.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)

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](https://webaloha.co/what-is-schema-markup-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.

64%

of schema implementations  
have errors

20-35%

CTR boost lost when  
rich results disappear

30 sec

to validate a page  
with the right tools

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](https://webaloha.co/schema-markup-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](https://schema.org/). 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](https://webaloha.co/tools/schema-markup-validator/) extracts all JSON-LD blocks from any URL, identifies every schema type, validates required properties, and flags specific issues with actionable warnings.

The [Schema.org Markup Validator](https://validator.schema.org/) (maintained by Google for the Schema.org community) is another solid option. It replaced the old Google Structured Data Testing Tool in 2021 and validates all schema types against the full vocabulary.

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

[Google Rich Results Test](https://search.google.com/test/rich-results) 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](https://search.google.com/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

| Tool | What It Checks | Input | Best For |
| --- | --- | --- | --- |
| Schema Markup Validator | All schema types, full Schema.org spec | URL or code snippet | Development, pre-publish checks |
| Google Rich Results Test | Google-supported types only | URL or code snippet | Rich result eligibility, JS rendering |
| Google Search Console | Site-wide schema health over time | Automatic (your verified site) | Ongoing monitoring, trend tracking |

Other tools worth knowing: [Bing Markup Validator](https://www.bing.com/webmasters/markup-validator) validates schema for Bing’s search features. [JSON-LD Playground](https://json-ld.org/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](https://webaloha.co/tools/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](https://search.google.com/test/rich-results)
4.  Also run it through a [schema markup validator](https://webaloha.co/tools/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](https://search.google.com/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](https://webaloha.co/tools/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](https://schema.org/) for your schema type’s required properties. For Google-specific requirements, check [Google’s structured data documentation](https://developers.google.com/search/docs/appearance/structured-data/search-gallery) for the type you’re implementing.

Fix: Add missing image to Article schema

```
{
"@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](https://jsonlint.com/)) to find the exact line with the syntax error. Common culprits: trailing commas, missing closing braces, unescaped special characters in text values.

✕Broken: trailing comma

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

✓Fixed: no 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](https://developers.google.com/search/docs/appearance/structured-data/sd-policies), 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](https://schema.org/docs/releases.html) for recent changes. Review [Google’s search gallery](https://developers.google.com/search/docs/appearance/structured-data/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](https://webaloha.co/tools/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](https://webaloha.co/schema-markup-ai-citations/), 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](https://webaloha.co/schema-markup-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

Validate Immediately

!After adding new schema markup

!After any CMS or plugin update

!After changing page templates

!After a site redesign or migration

!After changing domain or URL structure

!When Search Console reports new errors

Validate Periodically

●Weekly: check Search Console for new errors

●Monthly: test your top 5 traffic pages

●Quarterly: full audit of 10-15 representative URLs

●After bulk content imports or migrations

●After Google announces schema changes

●When rich results disappear from search

## Validation Checklist: Before Every Publish

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

JSON-LD syntax is valid (no trailing commas, all brackets closed, double quotes only)

@context is set to 'https://schema.org'

All required properties for your schema type are present

URLs are absolute (start with https://), not relative

Dates use ISO 8601 format (YYYY-MM-DD)

Schema content matches visible page content

No duplicate schema types on the same page

Image URLs point to actual, accessible images

Author is a Person object, not just a string

dateModified is current if the content was updated

Tested with a schema validator (zero errors)

Tested with Google Rich Results Test (eligible where expected)

## 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](https://webaloha.co/what-is-schema-markup-seo/) for the fundamentals
-   **Want AI visibility?** Learn [How Schema Markup Helps Your Business Earn AI Citations](https://webaloha.co/schema-markup-ai-citations/) for the AI search angle
-   **Need to build schema?** Use our [Schema Markup Generator](https://webaloha.co/tools/schema-markup-generator/) to create valid JSON-LD for 12 types
-   **Ready to validate?** Run your site through our [Schema Markup Validator](https://webaloha.co/tools/schema-markup-validator/) right now
-   **Want professional help?** Our [SEO services](https://webaloha.co/seo-services/) and [GEO services](https://webaloha.co/geo-services/) include full structured data implementation and validation

## Frequently Asked Questions

What is the best tool to validate schema markup?

There is no single best tool because each serves a different purpose. Use a schema markup validator for comprehensive syntax and property checks during development. Use Google Rich Results Test for rich result eligibility on live pages. Use Google Search Console for ongoing monitoring. The most effective approach is using all three as part of a workflow.

How do I check if my schema markup is working?

Three ways: view your page source and search for 'application/ld+json' to confirm the code exists. Run your URL through a schema markup validator for syntax and property checks. Use Google's Rich Results Test to verify rich result eligibility. For ongoing monitoring, check Search Console's Enhancements section.

What is the difference between the Schema Markup Validator and Google Rich Results Test?

Schema Markup Validator checks all schema types against the full Schema.org specification. Google Rich Results Test only validates types that Google uses for rich results and checks Google's specific requirements. Your schema can pass one and fail the other. Use both for thorough validation.

Why does my schema show no errors but I still don't see rich results?

Valid schema does not guarantee rich results. Google considers page quality, site authority, content policies, and whether it chooses to display rich results for specific queries. Rich results can also take days or weeks to appear after Google recrawls your page.

How often should I validate my schema markup?

Every time you change schema code, update plugins, or modify templates. Check Search Console weekly for new errors. Run a full audit quarterly on 10-15 representative URLs. Schema can break silently from CMS updates or template changes.

What are the most common schema validation errors?

Missing required properties (like 'image' on Article), invalid JSON syntax (trailing commas), wrong data types (text where numbers are expected), relative URLs instead of absolute, schema that doesn't match visible content, and duplicate schema types from multiple plugins.

Does schema validation affect SEO rankings?

Not directly. But valid schema enables rich results that boost click-through rates by 20-35%. More clicks lead to better engagement signals, which can indirectly improve rankings. Invalid schema means you miss these benefits entirely.

Can I validate schema markup before my page is live?

Yes. Most validators accept code snippets, not just URLs. Copy your JSON-LD and paste it into a validator's code snippet input during development. This is the recommended approach: validate code first, then validate the live URL after publishing.

* * *

## Validate Your Schema Markup Now

Find errors, fix issues, and make sure your structured data is working. Free, instant results.

[Validate Your Schema →](https://webaloha.co/tools/schema-markup-validator/)[Generate Schema Markup →](https://webaloha.co/tools/schema-markup-generator/)

Recommended tools

## Recommended tools for this guide

Use these free tools to apply the ideas from this guide to your own website.

[![Schema Markup Validator Tool Online](https://webaloha.co/_astro/tool-schema-validator.BRPmqvos_ZSW6A2.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)

Schema Markup Validator

](https://webaloha.co/tools/schema-markup-validator/)[![JSON-LD Formatter and Validator Tool Online](https://webaloha.co/_astro/tool-json-ld-formatter.BSzde6Hi_Z1TVr4b.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)

JSON-LD Formatter

](https://webaloha.co/tools/json-ld-formatter/)[![Schema Markup Generator Tool Online](https://webaloha.co/_astro/tool-schema-generator.OcNNsK7M_1cIavv.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)

Schema Markup Generator

](https://webaloha.co/tools/schema-markup-generator/)

Useful info? Spread the Aloha:

[![Lucky Oleg](https://webaloha.co/_astro/lucky-oleg.EPOIIvwX_Z1xOk2w.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)](https://webaloha.co/authors/lucky-oleg/)

[Lucky Oleg](https://webaloha.co/authors/lucky-oleg/)[](https://www.linkedin.com/in/luckyoleg/)

Lucky Oleg is the founder of Web Aloha, a web design & SEO agency helping businesses ride the digital wave. With years of experience in WordPress, technical SEO, and web performance, he writes about what actually works in the real world.

#### Related guides from Web Aloha

[![What Is Schema Markup and Why It Matters for SEO](https://webaloha.co/_astro/blog-schema-markup-seo.BtYPjzWE_OPc4E.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)

What Is Schema Markup and Why It Matters for SEO

](https://webaloha.co/what-is-schema-markup-seo/)[![How Schema Markup Helps Your Business Earn More AI Citations](https://webaloha.co/_astro/blog-schema-ai-citations.Od_1CdRM_Vlts9.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)

How Schema Markup Helps Your Business Earn More AI Citations

](https://webaloha.co/schema-markup-ai-citations/)[![WordPress 7.0 PHP Version: Requirements & Compatibility, Tested on Real Websites](https://webaloha.co/_astro/blog-wordpress-7-php-compatibility.BauuR2ng_hOkNB.webp?dpl=dpl_AM1rGg4hZQMeX9Xux5JT1y5ZTCmw)

WordPress 7.0 PHP Version: Requirements & Compatibility, Tested on Real Websites

](https://webaloha.co/wordpress-7-php-version-compatibility/)