Checking Structured Website Data with JSON-LD: What Search Engines Can Read

Management Summary
Structured data describes website content in a form that search engines can read, identifying things such as an article, organisation or image. JSON-LD is one format for adding these descriptions alongside the visible page. It can support richer search displays, but does not guarantee them. The article explains why counting data blocks is not a quality assessment: the descriptions need to match the page and the receiving service’s requirements, while a limited scan can miss parts of the information.
Contents
JSON-LD adds machine-readable descriptions to HTML, for example about articles, organisations or images. The browser does not execute this data block as JavaScript. Search engines can use the information; support by every preview service or assistant is not guaranteed.
The historical measurement of 6 September 2026 examined the delivered HTML from twenty domains without running JavaScript. It found 243 JSON-LD blocks. The limited analyser listed 97 objects from those blocks.

What a missing detection means
Nine responses contained recognised JSON-LD blocks and eleven did not. However, the eleven non-detections included HTTP 403 responses from Stack Overflow and Allegro. These blocked responses cannot establish the markup on the normal front pages. For the remaining nine responses, the finding only means that the tool recognised no matching block in the captured HTML.
Even a successful response without JSON-LD does not establish an absence of machine-readable information. Microdata, RDFa and other metadata were outside the test. The usefulness of JSON-LD depends on the content and intended consumer. Correct structured data can enable particular search appearances but guarantees neither that appearance nor a ranking improvement.
243 blocks do not mean 243 distinct things
A block here is a recognised <script type="application/ld+json"> element. One block can contain several objects, for example within @graph. Conversely, multiple blocks can describe the same object through the same identifier.
The Zeit response contained 164 recognised blocks and Heise 67; the other seven responses contributed twelve. The analyser listed at most forty objects per page, a limit reached by both Zeit and Heise. It does not fully traverse objects nested in properties such as author, and does not merge repeated identifiers. The 97 entries are therefore a tool counter, not a complete count of distinct JSON-LD nodes.
The types in the limited output
The 97 entries comprise 41 ItemList, 37 ImageObject, six WebSite, three Organization, three NewsMediaOrganization, four WebPage, and one each of CollectionPage, ProfilePage and Person. Lists and images account for 78 of the 97 entries. Limiting extraction to early objects can substantially bias this distribution.
ItemList describes a list and ImageObject an image. The type alone establishes neither an explicit order nor complete image dimensions or eligibility for a news carousel. Those conclusions require relevant properties and the rules of the particular consumer.
Three distinct validation layers
A reliable review separates valid JSON, JSON-LD and Schema.org meaning, and additional requirements of a search feature. The historical tool checklist marked thirteen entries complete, one as missing fields, and 83 as having no dedicated checklist. The affected WebSite entry was flagged for missing name and url. These counts do not establish overall quality.
The built-in checklists do not consistently match current Google requirements. For example, Google’s Article documentation currently lists recommended properties and explicitly states that none are required. The tool nevertheless demands an author, image and publication date among other fields. Such findings need comparison with current feature documentation.
Identifiers, contexts and types
JSON-LD permits relative identifiers. With the document URL https://example.com/about, "@id": "#organization" resolves to https://example.com/about#organization, unless a different base applies. Carefully chosen absolute identifiers often simplify stable references across pages; fragments are not inherently erroneous.
A context defines what the property names mean, for example which vocabulary supplies the name field. It can apply to contained objects without being repeated on each object. An object without an explicit type can also contain valid JSON-LD data, although a particular search feature may require a specific type. A full JSON-LD processor resolves these relationships; the tool’s simple search for the string schema.org does not replace that processing.
Interpreting dates and breadcrumb warnings
Dates need the format appropriate to the property and unambiguous time-zone information for timestamps. An earlier modification date can result from scheduling, imports or incorrect time-zone interpretation. Accurate timestamps should remain accurate; advancing a date merely to silence a checker is not a repair. The existing parser also accepts some invalid calendar dates.
Breadcrumbs describe a page’s place in a hierarchy, such as Home → Articles → Current article. Google’s requirements include names and positions. The final item may omit its item destination. A numbering gap warrants investigation but does not establish that every consumer discards all subsequent entries. HTML in a text value likewise needs assessment by property and consumer, rather than a universal claim about its presentation.
Extracting HTML data without claiming full validation
The following Python 3 example reads a locally saved UTF-8 HTML file. An HTML parser handles multiline blocks and different attribute orders. Invalid JSON is reported while later blocks are still processed. The example checks JSON syntax only: it runs no JavaScript and does not process contexts or the complete JSON-LD graph.
import json
import sys
from html.parser import HTMLParser
from pathlib import Path
class Blocks(HTMLParser):
def __init__(self):
super().__init__(convert_charrefs=False)
self.active = False
self.parts = []
self.blocks = []
def handle_starttag(self, tag, attrs):
if tag == "script":
kind = dict(attrs).get("type") or ""
self.active = kind.strip().lower() == "application/ld+json"
self.parts = []
def handle_data(self, data):
if self.active:
self.parts.append(data)
def handle_endtag(self, tag):
if tag == "script" and self.active:
self.blocks.append("".join(self.parts))
self.active = False
self.parts = []
def invalid_constant(value):
raise ValueError(f"Not a JSON constant: {value}")
parser = Blocks()
parser.feed(Path(sys.argv[1]).read_text(encoding="utf-8"))
parser.close()
failed = False
for number, raw in enumerate(parser.blocks, 1):
print(f"Block {number}")
try:
data = json.loads(raw, parse_constant=invalid_constant)
except ValueError as error:
print(f"Invalid JSON: {error}", file=sys.stderr)
failed = True
continue
print(json.dumps(data, ensure_ascii=False, indent=2))
print(f"Complete JSON-LD script blocks: {len(parser.blocks)}")
raise SystemExit(1 if failed else 0)Invocation: python3 jsonld-read.py page.html. The file page.html contains previously saved HTML. Unclosed script elements are not emitted as complete blocks.
The Live JSON-LD Structured Data Validator provides an initial overview subject to the limitations above. In the historical measurement, the Spiegel response was also cut off at the 1.5 MiB HTML limit. Data added after loading is outside this view.
Questions and answers
Must related data be in a single block?
No. General processing of embedded data under the JSON-LD specification requires merging all matching script blocks. A shared graph can simplify maintenance but is not a prerequisite for valid links. Individual consumers’ limitations require separate checking.
Does a strict CSP block JSON-LD?
A data block correctly declared as application/ld+json is not executed as a script and needs no script nonce or hash for that purpose. JavaScript that creates the block remains subject to CSP.
What content may be marked up?
For Google search features, descriptions must be relevant and accurately represent the actual page content. Misleading or hidden marked-up content can prevent eligibility. JSON-LD syntax alone does not establish this correspondence.
Are dynamically generated blocks always invisible?
No. Google supports structured data generated with JavaScript. Successful processing during rendering matters. A request without JavaScript shows only the delivered state; other consumers’ behaviour needs separate verification.


