Schema Markup in 2026: What It Is, How We Validate It, and Why It Actually Matters for AI

1. Schema Is a Vocabulary. JSON-LD Is a Syntax. These Are Not the Same Thing.

This distinction trips up more engineers than anything else I encounter, so I want to start here.

Schema.org is a shared vocabulary. It is a controlled list of types (Article, Product, LocalBusiness, Recipe, Organization) and properties (headline, price, datePublished, aggregateRating) that gives machines an agreed-upon name for the things on your page. It was founded jointly by Google, Microsoft, Yahoo, and Yandex, which is why it has survived as a de facto standard rather than fragmenting into vendor-specific formats.

Structured data is the broader practice. Google's own documentation calls it "a standardized format for providing information about a page" and classifying its content. The example Google uses is a recipe page: without markup, a crawler sees a wall of prose. With markup, it sees ingredients, a cook time, a temperature, and a calorie count as discrete, typed fields.

JSON-LD, Microdata, and RDFa are the three syntaxes, the actual encodings you write into HTML. Same vocabulary, three different delivery mechanisms.

Here is the smallest useful example, a JSON-LD block for an article:

<script type="application/ld+json">

{

  "@context": "https://schema.org",

  "@type": "Article",

  "headline": "Schema Markup in 2026",

  "author": {

    "@type": "Person",

    "name": "Jane Doe",

    "url": "https://example.com/authors/jane-doe"

  },

  "datePublished": "2026-09-05",

  "publisher": {

    "@type": "Organization",

    "name": "Example Media",

    "@id": "https://example.com/#organization"

  }

}

</script>

 

Three things to notice. @context points at the vocabulary being used. @type declares what kind of thing this is. @id gives an entity a stable, globally unique identifier, which is the mechanism that lets separate pages refer to the same organization instead of creating a new one each time. That last one is the property most teams skip, and it is the one that does the most work for entity resolution.

2. JSON-LD vs Microdata vs RDFa: The Comparison Nobody Runs Anymore

All three formats are technically equal in Google's eyes, provided the markup is valid. In practice the market has voted decisively.

Those adoption figures come from the HTTP Archive's 2024 Web Almanac, which found JSON-LD on 41% of crawled pages, up from 34% in 2022. The WebDataCommons corpus from the University of Mannheim tells the same story from a different angle: roughly 11.5 million websites emit JSON-LD, 7.6 million use Microdata, and only about 400,000 still use RDFa. Among sites that annotate anything at all, 70% reach for JSON-LD.

The macro trend is worth pausing on. That same corpus found structured data on 5.7% of examined webpages in 2010 and 51.25% in 2024. In fourteen years, marking up your content went from a fringe semantic-web experiment to something the majority of the web does, largely because WordPress, Shopify, Webflow, and Wix all emit it by default now.

My recommendation is unambiguous: use JSON-LD unless you have a specific reason not to. Because it is decoupled from the DOM, your markup does not break when a designer reorders a component. That single property is worth more in maintenance cost than every other consideration combined.

3. "Valid" Means Three Different Things, and Most Teams Only Test One

This is the section I would most like people to internalize. There is no single pass/fail state for structured data. There are three separate questions, and they have three separate tools.

The Schema Markup Validator is the descendant of Google's old Structured Data Testing Tool, which Google migrated to schema.org in April 2021 after stripping out its Google-specific checks. It validates against the schema.org specification and nothing else. It will happily green-light markup that Google will never render as a rich result.

The Rich Results Test does the inverse. It only evaluates the types that map to a supported Google search feature. Markup that is perfectly valid schema.org can come back clean in one tool and throw errors in the other, and both results are correct. They are measuring different things.

Google itself flags the third layer in its documentation, recommending the Rich Results Test during development and the rich result status reports after deployment, specifically because markup breaks post-launch through templating and serving issues. That is the failure mode I see most often in the wild. The markup was correct when a developer wrote it and silently broke six weeks later when someone shipped a CMS change.

4. The Five Validation Failures I See Over and Over

Missing required properties. Every Google feature guide specifies required, recommended, and optional properties. Miss a required one and you are not eligible, full stop. Google's guidance here is counterintuitive and worth quoting the substance of: it explicitly advises supplying fewer but complete and accurate recommended properties rather than cramming in every possible field with sloppy data. More markup is not better markup.

Markup that does not match visible content. This is a policy violation, not just a technical one. Google's structured data guidelines prohibit marking up information that is not visible to the user, even when that information is factually accurate. I have seen sites hit with manual actions over aggregateRating values that appeared nowhere on the rendered page.

Orphaned nested entities. You declare a publisher on your Article, and a separate Organization block elsewhere on the site, and nothing connects them. Without shared @id values you have created two organizations in the machine's model of your site instead of one. This is the single biggest missed opportunity in most implementations.

JSON-LD syntax errors. Trailing commas, unescaped quotes inside a description, a stray newline in a templated string. A single malformed character invalidates the entire block, not just the offending property. This is why templating engines that interpolate user-generated content into JSON-LD without proper escaping are a recurring source of silent failure.

JavaScript injection that never renders. Google can read JSON-LD injected by client-side JavaScript, but only if the script executes during rendering and is not blocked. If your markup arrives via a tag manager that fires after the render snapshot, it may as well not exist. Verify with the URL Inspection tool, which shows you the rendered DOM rather than the raw source.

5. Validating in CI, Not Just Before Launch

Manual spot-checking does not scale past a few hundred URLs. What has worked for us is treating structured data like any other build artifact.

We generate markup from typed source rather than hand-written strings. schema-dts, Google's TypeScript definitions for schema.org, turns a missing required property into a compile-time error instead of a production incident. We then run a validation step in CI against a sample of URLs per template, parse the JSON-LD out of the rendered HTML, and fail the build on schema errors. Finally, we set an alert on the Search Console rich result reports so that a spike in invalid items pages someone rather than sitting unnoticed in a dashboard for a quarter.

The point is that structured data has a shelf life. It decays through template drift, and the only defense is automation.

6. The AI Question, Answered Honestly

Now the part everyone actually came for. Does schema help you show up in AI answers?

The honest answer is that the evidence is genuinely mixed, and anyone giving you a confident yes or a confident no is selling something.

The case for. In March 2025, at SMX Munich, Fabrice Canel, Principal Product Manager at Microsoft Bing, stated on stage that schema markup helps Microsoft's LLMs understand content, as reported by Search Engine Land. Since Copilot grounds its answers in the Bing index, that is a direct line from your markup to an AI surface. Days later, Google structured data engineer Ryan Levering made comparable remarks at Search Central Live in New York, describing structured data as materially improving how Google's systems process pages. Levering's framing is the one I find most useful: this is infrastructure that makes retrieval more reliable, not a lever you pull for visibility.

The case against. Google's own guide to optimizing for generative AI features is blunt. Under a section literally headed "what you don't need to do," Google states that "structured data isn't required for generative AI search" and that there is no special schema.org markup you need to add. It goes on to say you should keep using it anyway as part of overall SEO, because it drives rich result eligibility. That is a narrower endorsement than the AEO discourse usually admits.

The controlled test. In May 2026, Ahrefs published the only large causal study I am aware of on this question. Louise Linehan and Xibeijia Guan tracked 1,885 pages that added JSON-LD between August 2025 and March 2026, matched them against roughly 4,000 control pages with similar pre-treatment citation levels, and ran a difference-in-differences analysis (a method that isolates the effect of a change by comparing it against a control group over the same period, filtering out platform-wide trends).

The results: Google AI Mode +2.4%, ChatGPT +2.2%, Google AI Overviews -4.6%. The first two are statistically indistinguishable from zero. The third is significant, with odds of roughly 1 in 2,500 that a gap that large happened by chance, and it points in the wrong direction. Ahrefs' own summary line is the one worth remembering: "Adding schema produced no major uplift in citations on any platform."

7. The Correlation Trap, Which Is the Most Interesting Part of the Story

Here is what makes that study genuinely instructive rather than just deflating.

Ahrefs first ran a broad correlational analysis across 6 million URLs and found that AI-cited pages were roughly three times more likely to carry JSON-LD than uncited pages. That is a huge gap, and it is the statistic that has been circulating for two years as proof that schema drives AI visibility. A separate SE Ranking dataset points the same way, with around 71% of ChatGPT-cited pages carrying structured data.

Then they tested whether the relationship was causal, and it collapsed.

The explanation is straightforward once you see it. Schema markup lives on well-maintained, technically sophisticated sites. Those same sites publish stronger content, earn more links, maintain cleaner information architecture, and rank better in conventional search. The markup is a proxy for site quality, not the cause of the citation. Every GEO deck that cites the 3x figure without running the causal test is committing a textbook confound.

Two caveats keep me from writing schema off entirely. First, every page in the Ahrefs treatment group was already being cited heavily, with 100 or more AI Overview citations before treatment. The study tells us that schema does not help pages the engines already see clearly. It cannot tell us whether schema helps a page break in for the first time, which is a different population entirely. Second, many LLM retrieval pipelines convert HTML to plain text or Markdown before the model reads it, and that conversion frequently drops <script> tags. If your JSON-LD is being stripped before the model ever sees it, the null result is a plumbing artifact, not a verdict on the vocabulary.

8. Where Schema Genuinely Earns Its Keep

Setting aside the citation question, there are four places where I still consider structured data non-negotiable.

Rich results, which remain measurable. Google's own case studies are the strongest numbers in this whole space. Rotten Tomatoes added markup to 100,000 pages and measured a 25% higher click-through rate on enhanced pages. Nestlé measured an 82% higher CTR on pages appearing as rich results. The Food Network converted 80% of its pages and saw a 35% increase in visits. Rakuten found users spent 1.5x more time on marked-up pages with a 3.6x higher interaction rate on AMP pages with search features. These are first-party numbers from the platform, not vendor case studies.

Entity disambiguation. If your brand shares a name with three other companies, @id values and sameAs links to authoritative profiles are how you tell every machine on the internet which one you are. This matters more, not less, as AI systems build entity graphs.

Commerce surfaces. ChatGPT's shopping features and Google's merchant experiences both consume structured product metadata: price, availability, reviews, variants. A stale price in your Product schema does not just fail to help you, it actively misrepresents you, and cached structured data is harder to correct than cached prose.

Agentic browsing. Google's guidance now explicitly discusses AI agents that inspect the DOM and the accessibility tree to complete tasks. Semantic HTML and accurate markup are how an agent books your reservation instead of giving up on your checkout flow.

9. The FAQ Deprecation Is a Governance Lesson

One last thing that changed the validation workflow this year and that a lot of teams missed.

On May 7, 2026, Google added a deprecation notice to its FAQ structured data documentation. FAQ rich results stopped appearing in Google Search. In June 2026 the FAQ search appearance filter, the rich result report, and Rich Results Test support were removed. In August 2026 the Search Console API support went away. There was no blog post. It was a small label at the top of a developer doc.

This was not a shock to anyone paying close attention, since Google had already restricted FAQ rich results to authoritative government and health sites back in August 2023, making the feature functionally invisible for most commercial sites for nearly three years. But it is a clean illustration of two things. First, if your reporting pipeline pulls FAQ dimensions from the Search Console API, it started returning nulls silently. Second, FAQPage remains a perfectly valid schema.org type. Google deprecated the display feature, not the vocabulary. The markup can stay, it just does not buy you a dropdown anymore.

The lesson I take from it: schema was never doing the work. The content was. When the SERP enhancement disappeared, the underlying Q&A content on those pages kept performing exactly as well as it had.

The Position I Have Landed On

Implement structured data. Use JSON-LD. Validate it in all three places, not one. Automate the validation so it survives template drift. Keep @id values consistent so your entities resolve cleanly across your site.

But do not sell schema as an AI citation strategy, because the only controlled test we have says it is not one. Treat it as what Levering described: plumbing that makes machine comprehension more reliable and less ambiguous. It amplifies content that is already strong. It will not rescue content that is not.

That framing is less exciting than the pitch decks. I think it is also the only one the evidence currently supports.

 

---

 

Sources and further reading

• Introduction to structured data markup in Google Search, Google Search Central

• Optimizing your website for generative AI features on Google Search, Google Search Central

• We Tracked 1,885 Pages Adding Schema. AI Citations Barely Moved., Louise Linehan and Xibeijia Guan, Ahrefs, May 2026

• Structured Data chapter, Web Almanac 2024, HTTP Archive

• WDC JSON-LD/Microdata/RDFa Data Corpus 2024, University of Mannheim

• Microsoft Bing/Copilot use schema for its LLMs, Search Engine Land, March 2025

• Google Drops FAQ Rich Results From Search, Search Engine Journal, May 2026

• Schema Markup Validator and Rich Results Test