Skip to content
Lizely

Structured Data Checker & Extractor

Extract JSON-LD and Microdata from pasted HTML, inspect each discovered item, and surface missing high-value properties with evidence-linked guidance instead of claiming rich-result eligibility.

Privacy: your files never leave your device. All processing happens locally in your browser.

How to use

  1. 1.Paste the delivered HTML source or a controlled rendered-DOM export; the checker never fetches or executes the page.
  2. 2.Run extraction, then review JSON-LD parse errors, Microdata items, declared types, properties, and focused missing-property warnings separately.
  3. 3.Fix the source template and validate the deployed URL with the official tool for the search feature you target.

About Structured Data Checker & Extractor

Structured Data Checker & Extractor turns pasted HTML into a readable inventory of the structured data already present in the document. It finds JSON-LD script blocks and HTML Microdata items, displays each discovered type, and reports focused property gaps for the supported profiles. All parsing happens in the browser. The source is not requested from a remote URL, executed as a page, or sent to Lizely.

The first job is extraction, not scoring. JSON-LD can contain one object, an array of objects, or an @graph containing several nodes. The checker expands those containers into individual items while preserving their declared @type values and visible properties. A malformed JSON block is reported separately, so one broken script does not erase valid items found elsewhere in the same document.

Microdata uses itemscope, itemtype and itemprop attributes inside ordinary HTML. The checker walks the parsed document and builds a bounded property view for top-level items. It recognizes values exposed through content attributes, links, media source attributes, date values and text content. Nested items remain visibly nested instead of being silently flattened into unrelated strings.

Validation is intentionally narrower than extraction. Schema.org defines a broad vocabulary, while search products publish their own required and recommended properties for particular experiences. The checker applies explicit, inspectable profiles only where the product has a documented rule set. An unknown type is still extracted, but it is not assigned invented requirements. A warning means the local profile did not find a property; it does not prove that a search engine will reject the page.

Syntax validity and search eligibility are different questions. Valid JSON can describe inaccurate, hidden or irrelevant content. A complete-looking object can still violate a search policy, disagree with the visible page, use an unsupported feature, or fail a deployment test. Conversely, Schema.org properties that are not part of a Google feature can still be meaningful to other consumers. The result therefore separates parse errors, missing focused properties and informational observations.

The checker does not fetch a live page. That boundary avoids cross-origin failures, private-network requests and a misleading audit of source that may differ from what a crawler receives. Copy the delivered HTML or a controlled DOM export into the input. If a framework injects markup after load, compare the original response, rendered DOM and crawler-visible output before drawing conclusions.

No script from the pasted document runs. A detached template fragment keeps parsed nodes outside the live page, and the interface renders bounded extracted values as text. The tool does not follow links, load images, submit forms or evaluate embedded JavaScript. Input size and item counts are bounded so an accidental full-site dump cannot freeze the page.

Use the extracted inventory to answer concrete questions. Is the intended type present? Did a template emit duplicate items? Is a required field missing from one variant? Does a JSON-LD block fail to parse? Does Microdata expose a blank URL because the wrong attribute was used? Fix the source template, then run the official validator for the search feature you actually target.

Google recommends JSON-LD for many structured-data features because it is generally easier to maintain, but it also supports Microdata and RDFa where documented. This tool extracts JSON-LD and Microdata only. RDFa is outside the current product boundary and is never counted as absent or invalid structured data. The limitation is shown so the result cannot be mistaken for a universal semantic-web validator.

Required-property guidance is not a substitute for content review. Markup should represent content users can actually see and should use specific, accurate values. Adding fields merely to silence a warning can make the implementation less trustworthy. Fewer complete and truthful properties are preferable to a large object filled with generic or fabricated values.

After making a change, validate the public URL with Google's Rich Results Test when the type targets a Google feature, inspect Search Console enhancement reports after recrawling, and test the actual page template across representative records. Search engines decide whether and when enhanced presentation appears. No local checker can guarantee indexing, ranking or a rich result.

The focused fixtures cover a valid JSON-LD object, an @graph, a top-level array, malformed JSON, a missing required property, multiple types, basic Microdata extraction and nested values. Negative cases include executable-looking pasted text, oversized source and unsupported structures. These checks protect deterministic parsing; they do not simulate every consumer.

Use the tool as a transparent preflight before official testing: paste authorized HTML, inspect every extracted item, resolve parse errors first, review profile warnings against the linked documentation, and then verify the deployed response. The output is evidence about the pasted document, not a promise about search appearance.

Methodology & sources

A detached browser template creates an isolated document fragment. The extractor expands JSON-LD objects, arrays and @graph nodes, walks bounded top-level Microdata items, normalizes declared types and properties, and applies only explicit supported-type property profiles. Parse errors, profile warnings and informational limitations remain separate.

Frequently asked questions

Does a clean result guarantee a Google rich result?
No. The checker reports facts about pasted markup; eligibility also depends on visible content, feature-specific policy, deployment, indexing, and Google's decisions.
Does the checker fetch or run my webpage?
No. It parses pasted HTML inside a detached browser template fragment and does not request URLs, execute scripts, load resources, or submit the source.
Why is an unfamiliar Schema.org type extracted but not graded?
Extraction can be general, but required-property rules are consumer and feature specific. The tool avoids inventing a validation profile without a documented contract.

Related tools

SEO & Webmaster guides

View all