Entity layer

Structured Data & Schema

Structured data is machine-readable markup that describes what a page is about, and for SEO its job is narrow but real: it makes your pages eligible for…

Structured data is machine-readable markup that describes what a page is about, and for SEO its job is narrow but real: it makes your pages eligible for certain Google rich results and helps search and AI systems disambiguate your entities. It is not a magic AI-citation lever — controlled studies show that engines extract visible on-page text and treat any schema they encounter as plain text. Use JSON-LD, keep your markup honest against what's visible, and treat schema as the supporting cast to strong, extractable content.

Pick one format and place it correctly

The format debate is settled: use JSON-LD everywhere. It lives in a <script type="application/ld+json"> block, so it survives DOM changes and framework hydration, and both search engines and AI systems parse it more reliably than markup embedded in HTML nodes. Google has recommended JSON-LD as its preferred format since 2017 and has deprecated several Microdata-only paths.

Reserve Microdata only for legacy platforms you genuinely cannot modify, and treat RDFa as near-obsolete outside academic and government publishing. Never emit mixed formats on the same entity — search engines will pick one unpredictably and ignore the other. See JSON-LD vs Microdata vs RDFa for the full comparison.

Placement rules that hold up in practice:

Inject critical entities (Organization, WebSite, BreadcrumbList) in the <head>.
Inject large entities (a Product with many offers, a big ItemList) before </body> to avoid blocking parse.
Use one <script> block per entity for clarity, or a single @graph array when entities reference each other via @id.
Never inject schema via client-side JavaScript only. Many AI and training crawlers do not execute JS reliably, so server-render or use static/incremental rendering.

Build an entity graph with @id

The single most-overlooked pattern is giving every entity a stable, fully-qualified @id URI. Use consistent fragment identifiers sitewide — #organization, #website, #webpage, #breadcrumb, #product-sku-12345 — so entities can reference each other:

{
  "@context": "https://schema.org",
  "@id": "https://example.com/#organization",
  "@type": "Organization"
}

This is how you wire together an entity graph that systems can traverse. Skipping @id is the top cause of fragmented entity recognition. The best example is authors: define a Person once at a stable @id, then reference it from every article with "author": {"@id": "https://example.com/authors/jane-doe#person"}. That cross-page linkage lets systems assess author authority across your whole site instead of treating each byline as isolated.

1Access

2Meaning

3Entity clarity

4Authority flow

5Evidence

6Consensus

7Engine measurement

The visibility stack: each layer depends on the ones below it

What schema actually earns you in 2026

Be honest about what structured data does and doesn't do. Its real value is threefold: rich-result eligibility, entity disambiguation through @id, sameAs, and Wikidata linkage, and clean machine-readable metadata. Google's own AI documentation states there's no special schema.org markup required for AI Overviews or AI Mode — eligibility is simply being indexed and snippet-eligible.

Controlled evidence backs this up. An Ahrefs difference-in-differences study (1,885 pages that added JSON-LD versus roughly 4,000 matched control pages) found no citation lift on Google AI Overviews, AI Mode, or ChatGPT. The widely quoted "AI-cited pages are ~3x more likely to have schema" correlation is confounded — schema-heavy sites tend to be better-maintained and better-linked overall. Multi-engine retrieval testing shows AI systems extract visible HTML and read any encountered schema as plain text.

The one controlled exception is local: a June 2026 study (EverGrow Marketing — 29 US green-industry domains, 36 locations, five-week window, methodology reviewed by several local-search practitioners) found no impact on Google, Bing, Yahoo, or Google Maps rank, but a ChatGPT position improvement of +3.3 and +10 percentage-point visibility gain at over 91% confidence on one of two tracked queries. Read it as directional, not definitive: LocalBusiness schema may be a cheap ChatGPT-specific local-visibility lever, but it's a small, single-vertical result — re-test it in your own vertical before weighting it heavily.

For the fuller picture, see Rich Results vs LLM Citations and the broader AEO & GEO layer.

The types worth your time

There are dozens of schema types, but they split cleanly into still-active Google rich results and dead ends. Detailed per-type guidance lives in Schema Types That Matter; here's the layer-wide map.

Type	Status	Notes
Product / Merchant listings	Strong	Requires numeric `price`, `priceCurrency`, `availability` as full URI, and a product identifier
Recipe	Strong	Carousels intact; use `HowToStep` arrays for instructions
Review / AggregateRating stars	Strong	Only within Product, Recipe, SoftwareApplication, Course
BreadcrumbList	Active	Still displays and boosts CTR
Event	Active	Needs `startDate` with timezone offset
JobPosting	Active, strict	Validated aggressively; needs `validThrough` and structured `baseSalary`
VideoObject	Active	Key moments, transcript as visible text
SoftwareApplication	Active	Requires rating or review for the rich result
Course	Active	Course list needs `hasCourseInstance`
Article / NewsArticle	Active	Top Stories, host carousels
ImageObject	Active	`license` + `acquireLicensePage` for the licensable badge
Organization	Indirect	Knowledge Panel inputs, logo, entity anchor
FAQPage	Dead	FAQ rich results removed for all sites in 2026
HowTo	Dead	Removed in 2024
Sitelinks Search Box	Near-dead	Rarely renders

A few layer-wide reminders. Always use the most specific subtype available — Dentist over LocalBusiness, NewsArticle over Article, ProfilePage over WebPage — because specificity improves both eligibility and classification. Your Organization entity is the anchor of the graph, and its sameAs array is where disambiguation happens; a Wikipedia or Wikidata link is the highest-value identity signal, with Crunchbase, LinkedIn, and platform profiles below. If you have no Wikipedia entry, a free Wikidata entry is the minimum worth pursuing.

Google's self-serving reviews policy still applies: you cannot use Review or AggregateRating on your own Organization or LocalBusiness for products or services you offer. Reviews are valid on Product, Recipe, Movie, Book, SoftwareApplication, and Course.

Pair schema with the visible structure that actually gets quoted

Since the real citation drivers are visible-text fundamentals, the highest-leverage work is structuring your DOM so retrievers can chunk and quote it. Schema corroborates that structure; it doesn't replace it. Deep patterns live in AEO Markup Patterns, but the principles apply across content types.

FAQ blocks: Put the question in a heading with a stable id, and the answer in the immediately following sibling. Lead with a complete, standalone answer sentence, then supporting detail. Keep answers roughly 40–80 words (an editorial heuristic, not a measured threshold). Avoid collapsed accordions where the answer renders as hidden. Emit FAQPage only when a page is genuinely Q&A-dominant — it's harmless but no longer drives results.
Comparison tables: These have the highest AEO leverage for "X vs Y" queries. Use a real <table> with <caption>, scope="col", and scope="row" — CSS-grid divs serialize as flat token soup. Keep cell values atomic, and add a plain-text verdict sentence near the table. There is no schema.org "comparison" type; model each item as its own entity instead.
Definitions: Lead with the term as the grammatical subject in the shape "X is a [category] that [distinguishing function]." Put the term in a <dt> or heading and the definition adjacent. DefinedTerm with a Wikidata sameAs is clean grounding metadata, though it produces no rich result.
How-to steps: Use an ordered list with one imperative action per step, each opening with a bolded verb and carrying a per-step id anchor. State total time and required tools before the list.
Statistics: Present one attributable stat per sentence with figure, subject, timeframe, and source inline — that's the quadruple that gets quoted with attribution.

This visible-first discipline connects directly to your On-Page SEO and Content Strategy & E-E-A-T work, and it's reinforced by Internal Linking that gives your entities authoritative context.

Validate, and keep markup honest

Validation is about two separate questions: will Google render a rich result, and does your markup conform to the vocabulary. Use Google's Rich Results Test for the first (it tests the rendered DOM and no longer supports FAQ or HowTo), and the Schema Markup Validator for spec conformance regardless of Google support — useful for non-Google targets. Bing's markup validator is increasingly relevant for Copilot. Full tool guidance is in Schema Validation Tools.

Two checks matter more than any tool report:

Entity graph cohesion. Resolve the full @graph and confirm every @id reference points to a defined node. Dangling references silently break entity traversal and degrade knowledge-graph matching.
Markup-vs-visible parity. Diff every factual claim in your JSON-LD — price, rating, review count, dates, availability, FAQ answers, step text — against the rendered visible text. Mismatches are the highest-severity finding, carrying a "spammy structured data" manual-action risk plus trust erosion. Schema for content that isn't visible on the page is a critical defect, not an optimization.

Also validate ISO 8601 strictly: dates like datePublished and startDate need timezone offsets, durations must use the PT#H#M#S form, and sanity-check that dateModified isn't earlier than datePublished or that prep and cook times sum to total time. Confirm rendering by fetching the page with JavaScript disabled — if schema or key content only appears after JS runs, fix it with server-side or static rendering, because non-Google crawlers may not execute JS reliably. This ties into your Technical SEO and Core Web Vitals foundations.

One caveat worth stating: individual crawler JS-execution behavior and exact carousel rendering shift quietly by query and locale, so re-confirm with your own fetching rather than trusting any static table — including this guide.

What to do

Standardize on JSON-LD sitewide and flag any Microdata or RDFa for migration; never mix formats on one entity.
Give every entity a stable, fully-qualified @id and wire related entities together, defining Organization, WebSite, and each author once.
Populate sameAs on your Organization and key Person entities with authoritative links; get at least a Wikidata entry if you have no Wikipedia page.
Implement still-active rich-result types (Product, Recipe, Event, JobPosting, VideoObject, SoftwareApplication, Course, Article, BreadcrumbList) using the most specific subtype available.
Stop treating FAQPage, HowTo, and the Sitelinks Search Box as missing opportunities; keep them only as optional metadata.
Structure the visible DOM first — answer-first FAQ pairs, real comparison tables, term-first definitions, ordered how-to steps, attributable stats — and treat schema as corroboration.
Run a markup-vs-visible-text parity diff on every page and resolve mismatches before shipping.
Validate dates and durations against ISO 8601, and confirm your schema renders in server HTML with JavaScript disabled.

save this card

Structured Data & Schema — key takeaways card

Download card

1080×1350 · post it anywhere