JSON-LD Structured Data Validator
Paste HTML or raw JSON-LD to validate FAQPage, BreadcrumbList, and Article structured data. Instantly spot missing required properties and common Google Rich Results mistakes.
What is the JSON-LD Structured Data Validator
JSON-LD is a markup format that tells Google, in a machine-readable way, what a piece of page content actually is — an FAQ, an article, a breadcrumb trail, and so on. You write it as JSON inside a <script type="application/ld+json"> tag, so it adds structured data without touching the visible HTML at all. When implemented correctly, it can unlock Rich Results in search, such as expandable FAQ snippets or breadcrumb trails, which tend to improve click-through rate even without any change in ranking.
This tool automatically extracts <script> blocks from pasted HTML (or accepts raw JSON-LD directly) and checks each FAQPage, BreadcrumbList, and Article-like entity (Article / NewsArticle / BlogPosting) against the required properties defined by Schema.org. It also flags the classic mistakes that quietly break Google's Rich Results — such as acceptedAnswer.text being an object instead of a plain string, or position values that are not sequential. Running this check before publishing, or right after a fix, catches problems earlier than waiting to spot them later in Search Console.
How to use the JSON-LD Structured Data Validator
- Get the HTML source or JSON-LD for your page Either the full "View Page Source" output of the page you want to check, or just the contents of a <script> tag, works as input.
- Paste it into the input box, or fetch it from a URL You can paste the text directly, or, for an already-published page, enter its URL and fetch it instead.
- Review the detected entities and their results If the input contains multiple <script> blocks or multiple @type entities, each one is listed and validated separately.
- Fix any property marked "Missing" or "Warning" Each property is marked OK, Warning, or Missing, so you can go straight to the corresponding spot in your original JSON-LD and correct it.
- Re-validate after fixing before you publish Paste the corrected JSON-LD back in and confirm every property shows OK before pushing the change live.
Tips for getting more out of it
- For FAQPage, acceptedAnswer.text must always be a plain string. Putting an object or array there means Google's Rich Results cannot parse it.
- For BreadcrumbList, keep position as a sequence starting at 1. Gaps or duplicates prevent it from being recognized as a valid breadcrumb trail.
- Keep Article's headline to around 110 characters or fewer, which is Google's rough guideline; longer headlines can be truncated in search results.
- You can paste an entire HTML page — the tool automatically extracts the contents of any <script type="application/ld+json"> block. Pasting just the raw JSON also works.
- If a page has multiple structured data blocks, keeping each one in its own <script> tag makes them easier to maintain and debug.
When this tool comes in handy
Checking FAQPage markup before it goes live
Catch classic mistakes — like an incorrectly structured acceptedAnswer.text — that silently prevent the FAQ rich snippet from ever showing up, before you publish.
Auditing breadcrumbs after a site restructure
When categories move or URLs change, confirm in one pass that BreadcrumbList position values are still in the right order.
Reviewing an Article schema on a blog post
Quickly check for an oversized headline or a missing author/datePublished/image, the recommended properties Google looks for on article-type pages.
Tracking down an error flagged by the Rich Results Test
When Google's official tool reports an error, narrow down exactly which property is at fault here first, then go fix the source.
Glossary
- JSON-LD
- A specification for writing structured data as JSON. It is embedded as an independent block inside a <script type="application/ld+json"> tag, so search-engine-facing information can be added without changing the existing HTML layout.
- Schema.org
- A shared vocabulary for structured data, jointly maintained by Google, Microsoft, Yahoo, and others. It defines types (@type), such as FAQPage or Article, and the properties each one supports.
- FAQPage
- A Schema.org type for telling Google about a list of questions and answers. Its mainEntity holds an array of Question entities, each of which requires a name (the question text) and acceptedAnswer.text (the answer text).
- BreadcrumbList
- A Schema.org type representing a breadcrumb trail — the page's position within a site's hierarchy. Its itemListElement holds an array of ListItem entities, each requiring a position, name, and item.
- Rich Results
- Enhanced search listings that show more than a plain title and description — such as an expandable FAQ snippet or a breadcrumb trail — and require correctly implemented structured data to appear.
- Required property
- A property Google needs in order to display a given Rich Result at all; missing it means the Rich Result simply will not appear. A recommended property, by contrast, is not strictly required but improves how the result is shown.
- Google Search Console
- Google's official tool for monitoring a site's search performance and indexing status. Its Enhancements reports show how Google is actually interpreting the structured data on your published pages.
Frequently Asked Questions
Side Note — Why JSON-LD replaced Microdata and RDFa
JSON-LD (JSON for Linking Data) originated as a Linked Data format standardized by a W3C community group in the early 2010s. Unlike the older structured-data notations, Microdata and RDFa, which embed markup directly into HTML element attributes, JSON-LD lives entirely inside a <script> tag as an independent block of JSON. That means structured data can be added, edited, or removed without touching the surrounding HTML layout at all. Google began favoring JSON-LD as its recommended format around 2015, and its current Rich Results documentation is written almost entirely around the JSON-LD syntax.
This site's own FAQ sections work the same way: authors write each question and answer once, and a matching FAQPage JSON-LD block is generated automatically behind the scenes. There is no need to hand-write the same content twice — once for the human-readable accordion and once for the machine-readable schema — so the two never drift out of sync the way manually duplicated markup tends to.
Even syntactically valid JSON can fail Rich Results if it is missing a property Schema.org requires, or a property Google recommends. Deeply nested fields like acceptedAnswer.text are a classic place to get the structure wrong. Running a check like this before publishing catches those mistakes earlier than waiting to notice an error later in Search Console's Enhancements report.