Best Structured Data Testing Tools 2027: 6 Schema Checkers

The best structured data testing tools for 2027: Rich Results Test, Schema Markup Validator and more, plus a 298-page JSON-LD check and a free script.

· BugViso Team

10 min read

The best structured data testing tools for 2027 are Google's Rich Results Test for whether a page can get rich results, the Schema Markup Validator for general schema.org correctness, Search Console's rich result reports for problems across your site, and a crawler such as BugViso for checking every page at once. Google's old Structured Data Testing Tool no longer exists; these replaced it.

Valid markup and markup that earns a rich result are different things. We checked all 298 pages of bugviso.com: every page had one JSON-LD block, none had a parse error, and 292 carried FAQPage markup. Yet since August 2023, Google shows FAQ rich results only for well-known government and health sites, so that FAQ markup passes every validator and still produces no rich result for us.

By the end you will know which tool answers which structured data question, the mistakes validators miss, and how to check the JSON-LD on any list of pages for free.

Data used: every URL in bugviso.com's sitemap (298 pages: 275 blog posts and 23 other pages), fetched on 2026-11-16. We extracted each application/ld+json block, parsed it, and counted the @type values. The script is in this post. Tool facts come from Google's and schema.org's own pages, fetched the same day. We make BugViso, one of the tools listed.

What 298 Pages of JSON-LD Looked Like

All 298 pages had valid JSON-LD; the interesting result is what kinds of markup they carry. Here are the counts.

Measure (298 pages)Result
Pages with at least one JSON-LD block298 of 298 (one block each)
Blocks that failed to parse0
Pages with Organization, WebSite and BreadcrumbList298
Pages with Article275 (every blog post)
Pages with SoftwareApplication23 (product pages)
Pages with FAQPage292
Distinct combinations of types12

The FAQPage count is the lesson. Google's August 2023 change to FAQ and HowTo rich results limited FAQ rich results to well-known, authoritative government and health websites. For other sites the markup is still valid and still describes the page for any machine that reads it, but a "valid" result in a tester doesn't mean Google will show the FAQ in search.

So a structured data test has two parts: is the markup correct, and is it the kind Google still uses for a rich result on your type of site.

The 6 Best Structured Data Testing Tools

ToolBest forTestsPrice
Rich Results TestWill this page qualify for a Google rich result?Google-supported types, rendered pageFree
Schema Markup ValidatorIs this schema.org markup correct?All schema.org types, JSON-LD, Microdata, RDFaFree
Search Console rich result reportsErrors across every indexed pageTypes Google found on your siteFree
BugViso site auditChecking markup on every crawled pageJSON-LD and Microdata, missing required propertiesFirst report free
The script belowA quick check of any URL listJSON-LD parse errors, types, key propertiesFree
View source / DevToolsSeeing what the server actually sentAnythingFree

Rich Results Test: Google's view of one page

Google's Rich Results Test renders the page like Googlebot and reports which rich result types it qualifies for, with errors and warnings for each. It's the tool to use before you publish a page you want a rich result for. It only reports on types Google supports for rich results, so markup it ignores isn't necessarily wrong.

Schema Markup Validator: correctness for any schema.org type

The Schema Markup Validator checks markup against the whole schema.org vocabulary, whatever the type, in JSON-LD, Microdata or RDFa. It took over the general validation job from Google's retired Structured Data Testing Tool. Use it for types Google doesn't turn into rich results but other consumers, including AI answer engines, may read.

Search Console rich result reports: problems at scale

Search Console shows a report for each rich result type Google found on your site, with valid items, items with warnings and invalid items. It's the only tool here based on what Google actually indexed. It lags behind your changes by days, so use it to monitor, not to test a fix.

BugViso: every page, every crawl

BugViso extracts JSON-LD (including @graph) and Microdata on every crawled page and validates them, flagging malformed JSON-LD and missing required properties such as an offer's price and currency. Its rules cover 23 common types, and the AI fixes in the report include corrected JSON-LD you can paste in. Where others go further: for a final yes/no on a Google rich result, confirm in the Rich Results Test.

The free script: a fast check of many URLs

The script below fetches each URL, parses every JSON-LD block, lists the types and flags a few missing key properties. It catches the most common breakage, invalid JSON from a template change, in seconds.

View source and DevTools: what was really sent

If a tester and your CMS disagree, look at the raw HTML. Markup injected by JavaScript appears in the rendered page but not in the source; Google can render it, but simple tools and some crawlers can't.

5 Structured Data Mistakes Testers Don't Flag

Validators check syntax and vocabulary; they can't tell whether the markup matches the page or still earns anything. These five slip through most often.

  • Markup that doesn't match visible content. A review rating or price in JSON-LD that isn't on the page breaks Google's structured data guidelines, described in its introduction to structured data, even if every tester says "valid".
  • Rich results Google no longer shows. FAQ and HowTo rich results changed in 2023; valid markup doesn't bring them back for most sites.
  • One template breaking every page. A trailing comma in a shared JSON-LD template makes every block on the site invalid at once. A crawl catches it; a single-page test may not, if you test the wrong page.
  • Duplicate entities. Two Organization blocks with different names or logos confuse anyone reading them. Keep one canonical entity and reference it.
  • Dates that never change. A dateModified stuck on the publish date undersells a refreshed page, and one that changes on every build overstates it.

Our guide on JSON-LD vs Microdata vs RDFa covers which format to choose, and how to validate schema markup walks through a full validation pass.

Run It Yourself: Check the JSON-LD on Any Page

This script finds every JSON-LD block on each URL, reports parse errors with the line number, lists every typed object (including inside @graph), and flags missing key properties for common types. It uses only Python's standard library.

python
#!/usr/bin/env python3
"""List and sanity-check the JSON-LD on a page: parse errors, types, missing key properties.

Usage: python3 jsonld_check.py <url> [more urls ...]
"""
import json
import re
import sys
import urllib.request

# shortcut: a few properties Google's docs list for common rich results, not a full validator.
EXPECT = {
    "Article": ["headline", "datePublished", "author"],
    "BlogPosting": ["headline", "datePublished", "author"],
    "Product": ["name", "offers|review|aggregateRating"],
    "Organization": ["name", "url"],
    "BreadcrumbList": ["itemListElement"],
    "FAQPage": ["mainEntity"],
    "SoftwareApplication": ["name", "offers|aggregateRating|review"],
    "LocalBusiness": ["name", "address"],
}


def nodes(data):
    """Every object with an @type, including those inside @graph and nested values."""
    if isinstance(data, list):
        for d in data:
            yield from nodes(d)
    elif isinstance(data, dict):
        if "@type" in data:
            yield data
        for v in data.values():
            yield from nodes(v)


for url in sys.argv[1:]:
    req = urllib.request.Request(url, headers={"User-Agent": "jsonld-check/1.0"})
    try:
        html = urllib.request.urlopen(req, timeout=20).read().decode("utf-8", "replace")
    except Exception as e:  # one dead URL shouldn't stop the rest
        print(f"{url}: FAIL ({e})")
        continue
    blocks = re.findall(r'<script[^>]+application/ld\+json[^>]*>(.*?)</script>', html, re.S | re.I)
    print(f"{url}: {len(blocks)} JSON-LD block(s)")
    for i, raw in enumerate(blocks, 1):
        try:
            data = json.loads(raw)
        except json.JSONDecodeError as e:
            print(f"  block {i}: INVALID JSON ({e.msg} at line {e.lineno})")
            continue
        for node in nodes(data):
            types = node["@type"] if isinstance(node["@type"], list) else [node["@type"]]
            for t in types:
                missing = [p for p in EXPECT.get(t, []) if not any(k in node for k in p.split("|"))]
                note = f"  missing: {', '.join(missing)}" if missing else ""
                print(f"  {t}{note}")

A test page with two deliberate mistakes, a trailing comma in one block and an Article without a date or author, gives:

text
http://127.0.0.1:8766/bad.html: 2 JSON-LD block(s)
  block 1: INVALID JSON (Expecting property name enclosed in double quotes at line 1)
  Article  missing: datePublished, author

The same script on our pricing page lists Organization, WebSite, SoftwareApplication with its Offer, WebPage, BreadcrumbList and FAQPage, with nothing missing. It checks only a handful of properties per type, so follow up anything you want a rich result for in the Rich Results Test.

How BugViso Validates Structured Data Across a Site

BugViso's structured data check runs on every crawled page in the real-browser audit, so markup injected by JavaScript is tested as Google would see it. It extracts JSON-LD, including @graph blocks, and Microdata, then validates against common types such as Organization, Product, SoftwareApplication and WebSite, flagging malformed JSON-LD, missing required properties like offers.price and priceCurrency, and pricing sections with no matching commerce schema.

Each finding is in the ranked fix list, and the AI-written fixes include corrected JSON-LD for the page. Because the crawl covers the whole site, a broken shared template shows up as one pattern across many URLs. The technical SEO feature page lists the checks.

Frequently Asked Questions

What replaced Google's Structured Data Testing Tool?

Two tools: Google's Rich Results Test, which checks whether a page qualifies for Google's rich results, and the Schema Markup Validator at validator.schema.org, which checks schema.org markup of any type. Use the first for Google search features and the second for general correctness.

How do I test structured data on my site?

Test one page in the Rich Results Test or the Schema Markup Validator, then check the whole site with Search Console's rich result reports or a crawler such as BugViso. For a quick scripted check of many URLs, the JSON-LD script in this post reports parse errors and types for each page.

Why does valid structured data not show rich results?

Valid markup is required but not enough. Google decides whether to show a rich result, some types are limited (FAQ rich results now appear only for authoritative government and health sites), and markup must match visible content. Check the Rich Results Test and Google's documentation for your type.

Is JSON-LD better than Microdata?

Google recommends JSON-LD because it sits in one script block, separate from the HTML, which makes it easier to add and maintain. Microdata and RDFa are still supported. Pick one format per page and keep the entities consistent.

Structured data describes your entities, products and content in a machine-readable way, which any system that reads the page can use. Google says its AI features draw on its normal Search index and need no special markup. Treat structured data as clear labelling, not a guaranteed route into AI answers.

The Structured Data Check That Matters Most

Valid markup is the floor, not the goal: test that every page's JSON-LD parses, that it matches what the page shows, and that the types you rely on still produce a result for a site like yours. To check every page in one pass, run a BugViso audit and open the structured data findings.

Written by

· BugViso Team

Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.

Found this useful? Share it.

Summarise with AI

Open this guide in your assistant.

Follow BugViso

New guides and audit data as we publish them.

AI visibility tracker

Is your brand in AI answers?

See how often AI assistants mention you, cite your site and rank you against your competitors.

  • ChatGPT
  • Gemini
  • Perplexity
  • Claude
  • AI Overviews
See how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.