The Structure Gate: Why JSON LD Beats HTML Semantics for AI Extraction

The Page Must Be Parseable

A page that passes Discovery is reachable and the entity is identifiable. It does not yet pass Structure. Structure is the second gate in the DSCRI ARGDW framework, and it measures whether the AI crawler can parse the page once it arrives. The answer in 2026 is consistent across engines: JSON LD with linked entity graphs is the parseable surface. HTML5 semantic tags help screen readers and Googlebot rankings, but they do not encode the entity relationships AI search needs to cite content reliably.

What HTML Semantics Solve, and What They Do Not

Semantic HTML5 tags (article, header, nav, aside, section, time) communicate document structure to user agents. A screen reader announces section boundaries. Googlebot uses the structure to assign canonical body content versus navigation. Microformats and hCard surface a thin set of entity claims via class attributes. All of these are useful and none of them are enough.

The gap: HTML semantics describe document shape but not entity identity. An <article> tag tells the crawler “this is the main body.” It does not tell the crawler “this article is about an Organization named Capital Wealth Advisors with Wikidata QID Q123456789, authored by a Person named Andres Plashal, published on 2026-07-07.” For AI extraction, entity identity is the unit. Document shape is incidental.

What JSON LD Solves

JSON LD encodes entity identity and relationships in a machine-parseable graph. Each entity (Organization, Person, BlogPosting, FAQPage) becomes a node. Each relationship (author, sameAs, isPartOf, mainEntity) becomes an edge. An AI crawler reading the graph extracts not “this page mentions an organization” but “this page is about Organization with QID X, authored by Person Y, on Date Z.”

The format won by 2025. Google, Perplexity, OpenAI, and Anthropic all consume JSON LD preferentially over alternative encodings. Microdata still parses but is treated as a fallback. RDFa exists in academic contexts. JSON LD is the de facto Structure-passing format for commercial content in 2026.

The @graph plus @id Pattern

Validity is not sufficient. Three valid schema blocks on a page (Organization, WebPage, BlogPosting) that do not reference each other produce a disconnected graph. The crawler sees three entities and must guess how they relate. The fix is the @graph plus @id pattern:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Capital Wealth Advisors",
      "sameAs": ["https://www.wikidata.org/entity/Q123456789"]
    },
    {
      "@type": "Person",
      "@id": "https://example.com/#person-founder",
      "name": "Jane Founder",
      "worksFor": { "@id": "https://example.com/#organization" }
    },
    {
      "@type": "BlogPosting",
      "@id": "https://example.com/blog/post-slug/#blogposting",
      "author": { "@id": "https://example.com/#person-founder" },
      "publisher": { "@id": "https://example.com/#organization" }
    }
  ]
}

Each @id is a globally unique anchor. Each reference (author, publisher, worksFor) points to a node by @id. The crawler reads the graph once and walks the edges. No guessing.

Five Common Structure Failures

Pages can ship schema and still fail Structure. Five frequent patterns:

1. Orphaned schema. Three blocks with no cross-references. Each is valid; together they fail to compose. Sites built without a foundation pattern tend toward this failure.

2. Conflicting @id values. Two BlogPosting nodes with the same @id on different pages, or two different @id values for the same logical entity. The crawler picks one and discards the others or refuses to disambiguate.

3. Missing required properties. A Person node without a name. A BlogPosting without datePublished. Schema validators do not flag these because they are recommended rather than strictly required, but AI crawlers downrank pages that lack them.

4. JSON syntax errors that the page still renders past. A trailing comma in a script type="application/ld+json" block. Browsers ignore the error and render normally. The schema does not parse. The crawler sees nothing.

5. Schema that contradicts visible content. A BlogPosting with datePublished: 2024-01-01 on a page whose visible byline says May 2026. The crawler trusts the schema; the LLM later cites the wrong date.

A real Structure audit checks for all five. Schema validators (Google’s Rich Results Test, the Schema.org validator) catch syntactic errors but not graph composition errors or content contradictions.

Worked Example

A mid-sized RIA had Organization, WebPage, BlogPosting, and FAQPage schema on every blog post. Each block validated cleanly. ChatGPT cited the blog content but consistently misattributed the author to a generic “industry expert” rather than the firm’s named principal.

Diagnostic: the schema graph was disconnected. The BlogPosting nodes had no author property pointing back to a Person node. The Person existed in the Organization schema as a founder, but without an @id anchor that the BlogPosting could reference. The crawler saw the BlogPosting and the Person but could not link them.

Fix: added "author": { "@id": "https://example.com/#person-founder" } to every BlogPosting, and "@id": "https://example.com/#person-founder" to the Person node inside the Organization schema. Two lines per page. Three weeks later, ChatGPT named the firm’s principal in citations.

Frequently Asked Questions

What about microformats (hCard, hRecipe, etc.)?

Microformats still parse but receive less weight from AI crawlers than JSON LD. Adoption is consistent enough that crawlers maintain parsers, but they treat microformats as fallback rather than primary. For new content, write JSON LD.

Should I emit JSON LD inline in the HTML, or via a separate endpoint?

Inline. AI crawlers fetch the HTML and extract from the script type="application/ld+json" block. Some crawlers do not follow separate endpoints reliably. Inline costs little and works universally.

Is RDFa worth using anywhere?

For academic content with established RDFa pipelines, yes. For commercial content, JSON LD outperforms on every measurement that matters in 2026.

How do I validate a graph composition error?

Use Google’s Rich Results Test plus a manual @id audit. Open the rendered page, copy the JSON LD block to a JSON parser, and trace every @id reference to confirm it resolves to a node in the same graph or to an external URL. Most graph composition errors are visible in five minutes of inspection.

Does the Astro Foundation handle this automatically?

Yes. The @plashal/astro-foundation package emits the @graph plus @id pattern by default for Organization, WebSite, WebPage, BlogPosting, and FAQPage entities. Sites built without the foundation pattern should retrofit; sites with it should validate that the foundation pattern is actually being used.

Next Gate

Once Structure passes, the page is parseable. The next gate, Content, measures whether the parsed passages clear the quality threshold AI engines apply before citation. Structure is plumbing; Content is editorial.