Structured data checker

What is the Structured data checker?

The Structured data checker inspects a page URL and reports the JSON-LD and Microdata structured data it contains. You submit the address of a page, the server fetches the page's HTML, and the tool scans the markup for structured data in both of the common embedded formats: JSON-LD blocks inside script tags and Microdata spread across itemtype, itemscope, and itemprop attributes. What you get back is a summary of what structured data the page is publishing and what format it uses.

Structured data is a standardized way of annotating a page's content so that a search engine can interpret it with confidence instead of guessing. JSON-LD carries its annotations in a single script block as a JSON object, while Microdata marks up the visible HTML itself with attributes that label each piece of content and its type. Both formats are widely used, and a page can legitimately carry one, the other, or both, which is exactly why the checker looks for both rather than assuming a single format.

What the Structured data checker checks

Submit a page URL and the tool fetches the page and scans its source for structured data. On the JSON-LD side, it looks for script blocks of the JSON-LD type and reads the objects they contain, noting what entity type each one describes, such as an article, a product, a breadcrumb trail, an organization, or a review. On the Microdata side, it looks for pages that declare an item scope with an item type, and it collects the itemprops that fill out those items.

The output is a summary of what it finds rather than a full validation report. The tool tells you whether the page carries JSON-LD, Microdata, both, or neither, lists the types of entities it detected, and shows the structured data that is present so you can see what a crawler would pick up. A page with no structured data simply reports that none was found, which is itself useful information when you are auditing a site that is supposed to be marked up.

Because the page is fetched and scanned by the server, the result reflects the markup in the HTML that is served publicly, the same source a search engine would fetch when it crawls the URL. There is nothing to run on your side: you supply only the address and the tool does the fetching and scanning.

One useful habit is to treat the check as a before-and-after record. Run it once before adding or editing markup to capture a baseline, then run it again after the change is live. The difference between the two readings tells you plainly whether the new snippet is being served, whether a caching layer is still delivering the old page, and whether the entity type you added is the one that appears. This turns the tool from a simple detector into a verification step in your publishing workflow.

How to use the Structured data checker

Checking a page takes a single submission; you only need the full URL of the page you want to inspect.

1. Copy the full URL of the page whose structured data you want to inspect, including the protocol and the complete path.
2. Paste the URL into the input field, making sure it points directly at the page rather than at a service or redirect wrapper.
3. Submit the form and wait for the server to fetch the page and scan its source for JSON-LD and Microdata.
4. Read the summary to see which format or formats the page uses and which entity types the structured data describes.
5. Review the detected items against what the page actually shows, and note any places where markup and content disagree.

How to get better results

• Check the exact URL a page is served at, including its canonical form, because the markup present can differ between the bare domain, the www version, and parameterized versions.
• Use the checker after adding or editing structured data, so you can confirm the new block is actually being served on the live page rather than only in a staging copy.
• Re-check after template or theme changes, since a platform update can silently drop the script blocks or item attributes that were carrying your markup.
• Note whether the page relies on one format only, since mixing JSON-LD and Microdata for the same content is a common source of confusion when other validators report conflicting results.
• Look beyond the presence of markup to whether the detected entity types match the page's real content, such as a product schema on a product page rather than on a blog post.
• Test a handful of representative pages from a section rather than one page, so you catch templates that mark up some pages and leave others bare.

Why the Structured data checker matters

Structured data only helps when it is actually present on the page a search engine fetches. Markup that exists in a development copy, was stripped by a template change, or sits in the wrong format is invisible to the systems that would use it, and the failure is easy to miss because the pages still look fine to visitors. A check that inspects the served source closes that gap by confirming what is really being published.

For audit work the tool is useful in a wider sense. When you take over a site, refresh its markup, or chase a drop in rich results, the first question is always what structured data exists right now and in which format. Knowing the answer in a single submission lets you focus on the pages that lack markup entirely, the ones carrying an unexpected type, or the ones mixing formats, instead of reading raw HTML across every template on the site to reach the same conclusion.

The format distinction is worth calling out on its own. JSON-LD and Microdata are equivalent in the eyes of search engines, but they are maintained very differently: JSON-LD lives in one block that a template can generate and swap easily, while Microdata is woven through the visible HTML and changes whenever the markup or the copy changes. Knowing which one a page uses tells you where to look when something breaks and how much effort a migration between the two would involve, both of which are decisions you want to base on the actual state of the page rather than on assumption.

When to use the Structured data checker

• When you have just added a JSON-LD or Microdata snippet to a page and want to confirm it is actually served in the live HTML.
• When a page used to show rich results or richer snippets and no longer does, to check whether its markup is still present and correct.
• When you inherit or audit a site and need a quick picture of what structured data each page publishes and in what format.
• When you change a template or move platforms and want to confirm the update did not strip the structured data from the generated pages.
• When a fresh page needs markup and you want to check a similar existing page first, so the new one can be built to match whatever pattern is already in use.

Related SEO Tools

Complete your SEO workflow with these related free tools:

• SERP checker - Get the top search engine results for a keyword.
• Indexed pages checker - Check if a domain is indexed by search engines.
• Website status checker - Check the status and availability of a website. Verify a site is online and responding before sharing or monitoring it.
• SSL checker - Check the SSL status and information of a domain. Review certificate validity, issuer, and expiry for a site.

Related SEO Guides

Learn more about this topic with our in-depth guides:

• Schema Markup for Beginners: A Structured Data Guide
• Structured Data Testing and Validation: A Complete Guide
• Meta Tags Checker vs Google Search Console: Which Shows the Real Data?

Frequently asked questions

Which structured data formats does the checker detect?

It detects the two common embedded formats: JSON-LD blocks carried in script tags and Microdata marked up with itemtype, itemscope, and itemprop attributes. A page that uses only one format is reported as such, and a page using both is identified as well, which matters because many pages legitimately mix the two across different parts of the template.

Does the checker validate the structured data, or just detect it?

It detects and summarizes what is present, reporting the format and the entity types found, rather than running a full validation of every property against its specification. A separate validation step is still worth doing for markup you plan to rely on.

How is the page fetched?

The server requests the URL directly and scans the HTML that is returned, so the markup you are told about is the markup actually served on the public page at the time of submission. That means a page behind caching or a CDN is scanned as it is really delivered, not as it exists in a staging file.

What if the checker reports no structured data?

That means the page returned no JSON-LD block and no Microdata markup. If you believe the page should carry markup, check for delivery conditions, canonicals, or caching that might be serving an older or different version.

Can I check a page behind a login?

Only pages the server can fetch as a regular request are checked. Content that requires authentication or blocks automated fetching will not return markup for inspection.

How often should I re-run the check?

Whenever the page changes in ways that touch its markup: template edits, plugin updates, platform migrations, or content rework that regenerates the page. A check after each significant change keeps you aware of whether the structured data survived.