A schema markup checker inspects a web page (via URL or pasted source code) and reports which structured data types it finds, whether they are valid, and which rich results they are eligible for. This guide explains the checking workflow, how to interpret results correctly, and how to scale schema auditing across large websites.

1. The Schema Checking Workflow

Enter your URL or paste source

URL-mode fetches the live page as a bot would see it — showing what Googlebot actually receives. Code-mode lets you test before deploying.

Identify detected schema types

A good checker lists every @type found: Article, Product, BreadcrumbList, Organization, etc. If a type you expect is missing, the schema may not be server-rendered.

Read the errors (red)

Errors indicate the schema violates the schema.org spec or fails Google's requirements. Errors prevent rich result eligibility for that type.

Review the warnings (amber)

Warnings flag missing recommended properties that would improve rich result quality — e.g. missing image on Article, missing priceValidUntil on Product. Not blocking but worth fixing.

Check rich result eligibility

Some checkers show which rich results each valid schema type qualifies for (Recipe card, FAQ dropdowns, etc.). This is the most actionable output.

2. Best Schema Markup Checkers Compared

Tool	URL Check	Code Check	Rich Result Preview	Free
SchemaValidator.org	✅	✅	✅ Full report	✅
Google Rich Results Test	✅	✅	✅ Visual preview	✅
Google Search Console	✅ (crawled pages)	❌	⚠️ Aggregate only	✅
Screaming Frog SEO Spider	✅ Bulk crawl	❌	❌	⚠️ 500 URLs free
Sitebulb	✅ Bulk + audit	❌	⚠️ Error reporting	❌ Paid

3. Interpreting Errors vs Warnings

🚩 Errors (must fix)

Errors mean Google will not treat this schema as valid. The type may still be parsed, but rich result eligibility is blocked. Fix all errors before deployment.

• Missing required property (e.g. name on LocalBusiness)

• Invalid property type (e.g. string where URL expected)

• Empty value for required field

• Unrecognised @type or property name

⚠️ Warnings (should fix)

Warnings mean the schema is valid but has missing recommended properties. Rich results may show, but will be less detailed. Fix warnings for maximum CTR.

• Missing image on Article (reduces Top Stories eligibility)

• Missing priceValidUntil on Product Offer

• Missing description on any type

• Review count present but no reviews array

4. Bulk Schema Checking at Scale

For websites with hundreds or thousands of pages, checking page-by-page is not practical. Google Search Console is the right tool for this:

GSC Enhancements reports

Google Search Console → Enhancements shows a list of all schema types Google has found across your entire site, with aggregate counts of valid, warning, and error pages. This is your primary bulk monitoring dashboard.

GSC URL Inspection

Inspect any individual URL in GSC to see exactly what structured data Google last parsed from that page. Note: this shows the cached version, not necessarily live.

Screaming Frog custom extraction

Configure Screaming Frog with a custom extraction rule to scrape the application/ld+json content from every page, export to CSV, and bulk-validate with a script.

Schema.org API + custom scripts

For developers: write a script that fetches each URL from your sitemap, extracts JSON-LD blocks, and validates them against the schema.org JSON schema definitions.

5. What a "Clean" Schema Check Report Looks Like

✅ Types detected: Article, BreadcrumbList, Organization, WebPage

✅ Errors: 0

✅ Warnings: 2 (missing image dimensions on logo, missing keywords on Article)

✅ Rich results eligible: Article Card, Breadcrumb, Sitelinks Searchbox

✅ Rendering: Server-side (detected in HTML source, not injected by JS)

6. What Validation Cannot Tell You

Schema checkers are powerful but have well-defined limits. Understanding what they do not catch prevents false confidence in your schema health:

⚠️ Whether Google will actually show the rich result

A zero-error schema check means you are eligible for a rich result — not that you will get one. Google evaluates content quality, page authority, query relevance, and competition before deciding whether to show the rich result.

⚠️ Rendering issues on JavaScript-heavy pages

URL-based checkers fetch the HTML source. If your schema is injected by JavaScript after page load (not server-rendered), the checker may not see it. Always also test with Google's Rich Results Test which uses a full Googlebot renderer.

⚠️ Schema accuracy vs page content

A checker confirms the schema is structurally valid. It does not verify that the values match what is actually on the page. A Product schema with an inflated ratingCount will pass validation but violate Google's quality guidelines.

⚠️ Cross-page schema consistency

If your Organization @id on the homepage does not match the publisher @id used on article pages, the entity graph is broken. Single-page checkers will not catch this cross-page inconsistency. Only a full site audit will.

⚠️ Manual action risk

No checker can tell you whether your schema is flagged for spam review or has triggered a Google quality policy review. Only Google Search Console Manual Actions will show this.

7. Automated Schema Checking in CI/CD Pipelines

For development teams deploying schema changes frequently, manual checking is not sufficient. Here is how to add schema validation to your deployment pipeline:

# Example: Node.js pre-deploy schema check
# Install: npm install schema-dts jsonld

import * as fs from 'fs';

const validateSchema = async (jsonld) => {
  // Option 1: Validate against Schema.org JSON Schema
  const response = await fetch(
    'https://validator.schema.org/validate',
    {
      method: 'POST',
      body: new URLSearchParams({ url: 'your-staging-url' }),
    }
  );
  const result = await response.json();
  
  if (result.errors && result.errors.length > 0) {
    console.error('Schema errors:', result.errors);
    process.exit(1); // Fail the build
  }
  
  console.log('Schema valid ✓');
};

// Check schema files before deployment
const schemas = JSON.parse(
  fs.readFileSync('./public/schemas.json', 'utf8')
);
await validateSchema(schemas);

For simpler pipelines, use JSON linting as a pre-commit hook to catch syntax errors before they reach production:

# .git/hooks/pre-commit
#!/bin/bash
# Validate all JSON-LD files before commit
for file in src/**/*schema*.json; do
  python3 -m json.tool &quot;$file&quot; > /dev/null 2>&1
  if [ $? -ne 0 ]; then
    echo &quot;Invalid JSON in $file&quot;
    exit 1
  fi
done
echo &quot;All schema files valid ✓&quot;

8. Interpreting GSC Enhancements Error Messages

Google Search Console uses specific error and warning messages. Here are the most common ones and what they actually mean:

GSC Message	Meaning	Fix
Missing field 'name'	Required property not present in schema	Add the missing property to your JSON-LD
Either 'offers', 'review', or 'aggregateRating' should be specified	Product schema needs at least one of these	Add an offers block with price and availability
Invalid value type for field 'price': expected type Number	Price must be a string, not a number, in schema	Change 19.99 to '19.99' (quoted string)
The value provided for logo is not valid	Logo URL format is wrong or missing dimensions	Use an ImageObject with url, width, height
AggregateRating.reviewCount must be a positive integer	reviewCount is 0, float, or missing	Set a real integer: reviewCount: 47

Frequently Asked Questions

What is the difference between SchemaValidator.org and Google's Rich Results Test? ▼

Both validate structured data, but serve different use cases. Google's Rich Results Test shows a visual preview of how a rich result will look in Google Search specifically, and uses Googlebot's actual renderer. SchemaValidator.org gives a more detailed technical report — identifying every schema type found, all errors and warnings, and rich result eligibility across types. Use both: SchemaValidator for development and debugging, Rich Results Test for final production verification.

My schema passes validation but still does not appear as a rich result. Why? ▼

Passing validation means you are eligible — not guaranteed. Google evaluates additional signals: page authority (low-authority new pages earn rich results slower), content quality (thin or auto-generated pages are deprioritised), query relevance (the rich result only shows for queries where Google deems it helpful), and competition (Google shows the most useful result format for a query, not necessarily the most decorated one). Check GSC Enhancements to confirm Google has detected and processed the schema.

How do I check schema on a page that requires login? ▼

URL-based checkers fetch the page as a bot — they cannot log in. Options: (1) paste the page source directly into the code input mode of the validator, (2) use a browser extension that highlights JSON-LD on logged-in pages, (3) for Google-specific checking, use GSC URL Inspection on any indexed page since Googlebot uses your crawl settings. Pages behind authentication should not need schema on the gated content anyway.

Google Search Console shows hundreds of schema errors across my site. Where do I start? ▼

Prioritise by impact: (1) fix errors on your highest-traffic pages first — these have the most to gain from unlocked rich results, (2) focus on schema types that are close to valid (1–2 errors) before tackling deeply broken implementations, (3) look for patterns — the same error repeating across many pages usually means a template fix will resolve hundreds of issues at once, (4) ignore warnings initially; fix errors first.

Does a schema checker catch content mismatch issues (e.g. fake ratings)? ▼

No — schema validators check structure and syntax, not semantic accuracy. A Product schema claiming ratingValue: 5.0 with reviewCount: 50000 on a new product with zero reviews will pass validation with no errors. Google uses separate algorithmic and manual review processes to detect schema spam. The validator cannot warn you about misleading data — that is your responsibility to ensure accuracy.

I added schema but the checker shows it is JavaScript-rendered, not in HTML source. Is that a problem? ▼

It can be. Google uses a two-wave rendering process: it first crawls HTML, then queues JavaScript rendering (which can take days or weeks for low-priority pages). Schema injected by JavaScript (e.g. via useEffect or GTM) may not be seen immediately. For best results, server-render your JSON-LD so it is in the initial HTML response. In Next.js this means adding the script tag to your server component or layout.

Can I use a schema checker for competitor analysis? ▼

Yes — paste any competitor URL into a URL-based checker to see exactly what schema they are using, which types they have implemented, and any gaps or errors they have. This is a useful tactic for understanding why competitors earn rich results you do not — check their Product, Article, or FAQ schema to see what you are missing.

What does "Recommended property missing" mean in a schema validation report? ▼

It means a property that is not required for rich result eligibility is missing, but adding it would improve the rich result quality. For example: missing image on Article (reduces Top Stories eligibility), missing priceValidUntil on Product (Google may display price as potentially stale). These warnings do not block rich results but are worth fixing for maximum SERP performance.

Check Your Schema Markup Now

Enter a URL or paste code — get an instant schema check with error, warning, and rich result report.

Check Schema Markup →

Related Guides

→ Testing Tools Guide

Detailed comparison of all schema testing and validation tools

→ Schema Markup Audit

Full site schema audit process for large websites

→ Google Rich Results Guide

What rich results each validated schema type unlocks

→ JavaScript SEO & Schema

Ensure schema is server-rendered and visible to checkers

→ Schema Markup & CTR

The CTR impact of fixing schema errors and earning rich results

→ What is Structured Data?

A complete introduction to schema and structured data

Schema Markup Checker: How to Check Any Page for Structured Data