Skip to content

Structured Data Checker

Short answer

Check the JSON-LD on a page: that every block parses, the schema.org types it declares, basic fields such as @context and @type, and whether Organization, WebSite and BreadcrumbList are present.

What it does not do: It checks that JSON-LD parses, its types and a few basic fields, not every required property of each rich result; microdata, RDFa and markup added by scripts are not read.

Free · No signup · Runs in your browser
100% in your browser — your content never leaves your device.

What It Does

Extracts every JSON-LD block on your page and reports in two parts. JSON-LD validity: whether each block parses as valid JSON and which schema.org types it declares (Organization, Product, Article and so on). Entities and required fields: whether each entity has @context and @type, whether an Organization has a name and a WebSite a url, and which core entities (Organization, WebSite, BreadcrumbList, Article, Product, LocalBusiness) the page declares. The score is the average of the two parts.

Why It Matters

Structured data describes a page in a form search engines can read, and Google uses it for rich results such as product prices, review stars and breadcrumbs. A JSON-LD block that does not parse is ignored completely, and one CMS or plugin update can break every page that shares a template. Checking the markup after each release catches that early.

How It Works

  1. Enter a page URL or paste its HTML

  2. We extract every JSON-LD block from the HTML, including the entities inside an @graph

  3. Check that each block parses and that each entity has @context, @type and its basic fields

  4. Return the types found, any errors and which core entities are present or missing

Sample input + output

INPUT
url: https://rankproof.eu/tools
OUTPUT
JSON-LD validity                          100/100
  JSON-LD blocks: 1 · schema.org types: 5
  invalid blocks: 0                        OK
  types found: Organization, SoftwareApplication,
    WebSite, CollectionPage, ItemList

Entities and required fields               92/100
  entity types: 5 · errors: 0 · warnings: 0
  Organization, WebSite                    present
  BreadcrumbList                           missing
  Article, Product, LocalBusiness          missing

Score: 96/100 — 2 of 2 parts in good shape

How to read the result

JSON-LD blocks (1 in the sample)
How many <script type="application/ld+json"> blocks the HTML contains. One block that holds an @graph is as good as several separate blocks; the count mainly tells you where to look when something breaks.
Types found (5)
The schema.org types declared at the top of each block or inside its @graph — in the sample Organization, SoftwareApplication, WebSite, CollectionPage and ItemList. Types nested inside a property, such as an address inside an Organization, are not listed separately.
Invalid blocks (0)
Blocks that are not valid JSON. A single stray comma or unescaped quote makes search engines ignore the whole block, so any error here is the first thing to fix.
Entities and required fields (92/100)
The second part reads every entity, including those inside an @graph: each needs @context and @type, an Organization needs a name and a WebSite a url, and errors or warnings are listed one per line. It also shows which core entities the page declares. In the sample Organization and WebSite are present; of the missing ones only BreadcrumbList lowers the part, because Article, Product and LocalBusiness describe kinds of page that /tools is not.
Score (96/100)
The average of the two parts, 100 and 92. The summary line counts the parts in good shape and is green only when both are; a page with no JSON-LD at all scores 0 in both.
What a pass does not mean
Valid JSON with the basic fields is the first step. Whether the markup can earn a rich result depends on the required properties of each type and on Google's guidelines, which the Rich Results Test and the Search Console enhancement reports check.

Who Uses This

  • Technical SEO

    Before launch, confirm the Article, Product and BreadcrumbList blocks on each template parse without errors.

  • E-commerce developer

    Check a product template after every platform update to catch broken Product markup.

  • Content manager

    Confirm the Article markup on your top articles still parses after a theme or plugin update.

Common problems and how to fix them

  1. A block fails to parse

    Look for a comma after the last property, a quote inside a value that is not escaped, or a template variable that printed nothing. Paste the block into a JSON validator to find the line, then fix the template that produces it so every page is repaired at once.

    {
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Ltd",
  "url": "https://example.com"
}

  2. The page has no structured data

    Start with what describes the whole site — an Organization (or Person) and a WebSite node in the site template — then add the type that matches each page: Article for posts, Product for product pages, BreadcrumbList where breadcrumbs are shown.

    <script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    { "@type": "Organization", "@id": "https://example.com/#org", "name": "Example Ltd", "url": "https://example.com" },
    { "@type": "WebSite", "url": "https://example.com", "publisher": { "@id": "https://example.com/#org" } }
  ]
}
</script>

  3. FAQ or HowTo markup brings no rich result

    FAQPage and HowTo are still valid schema.org types, but Google no longer shows FAQ or HowTo results in Search. Keep the markup only if something else uses it, and do not expect a richer listing from it.

  4. The markup says more than the page shows

    Google's guidelines require structured data to describe content that visitors can see. Ratings, prices or events that exist only in the markup can lead to a manual action, so generate the JSON-LD from the same data the page displays.

  5. The markup is added by a script

    This tool reads the HTML as delivered, so JSON-LD inserted by JavaScript is not counted. Google can read injected JSON-LD, but other search engines and tools may not; printing it in the server HTML is the safe choice.

  6. BreadcrumbList is missing

    Add BreadcrumbList on pages that show a breadcrumb trail, built from the same trail the visitor sees, so the markup and the page cannot disagree. Google can use it to show where the page sits in your site instead of the bare URL.

Frequently Asked Questions

Does it check rich result eligibility?
No. It checks that each block parses, lists its types and checks a few basic fields (@context, @type, an Organization's name, a WebSite's url). Each rich result has its own required properties; check those with Google's Rich Results Test.
Should I use JSON-LD, microdata or RDFa?
Google supports all three and recommends JSON-LD, which is the easiest to add and maintain. This tool reads JSON-LD only.
Which types can still earn rich results?
Google lists the supported types in its Search Gallery, for example Article, Product, Breadcrumb, Event, Local business, Recipe and Review snippet. FAQ and HowTo rich results are no longer shown in Google Search.
Does it see markup added by JavaScript?
No. It reads the HTML as delivered, so JSON-LD that scripts add later is not included.
Why does it look for Organization and WebSite?
They say who publishes the site and what it is called. Google uses WebSite structured data, with other signals, to choose the site name it shows in results, and Organization markup for details such as the logo. They belong in the site template, so one change covers every page.

Sources

The documentation this tool and the explanations on this page are based on.

Free tools on this topic

Guides on this topic

Research data on this topic

Related Tools in SEO Analysis

View all SEO Analysis tools