Does Schema Markup Matter for AI Search? The Honest Answer

"Add schema markup, get cited by AI." That pitch is everywhere in 2026 — in agency decks, in LinkedIn posts, in no shortage of tools promising to "optimize" a site for AI search with a JSON-LD snippet. It's not hard to see the appeal. Structured data is cheap, technical enough to sound authoritative, and it gives a business owner something concrete to do while the rest of AI search feels completely out of their hands.

Then someone tested it directly. In May 2026, Ahrefs tracked 1,885 pages that added schema markup and measured what happened to their AI citation rates over the following month.

The citation rates barely moved.

That leaves an uncomfortable question: if adding schema doesn't produce more citations, does schema still matter for AI search?

Yes. Just probably not for the reason most of the pitches are giving you.

The Short Answer

Schema markup is still worth implementing. It gives search systems explicit, standardized information about a page — what it's about, who wrote it, what organization stands behind it, what it's selling. Google documents structured data as helping its Search systems understand a page and gather information about the people, organizations, and products it describes.

What the current evidence does not support is the specific claim being sold hardest: that adding JSON-LD to a page causes ChatGPT, Google AI Mode, or another answer engine to cite it more often.

Those are different claims, and this article keeps them separate. Four ideas recur throughout, and they are not interchangeable: machine understanding, retrieval, citation, recommendation. A system can understand what a page is about without retrieving it for a given query. It can retrieve a page without citing it in the answer. It can cite a page without recommending the business behind it. Structured data has a documented role in that first step — machine-readable understanding — within major search ecosystems like Google and Bing. Its role inside every other AI retrieval system is not publicly documented, and the evidence for the other three steps is thin to nonexistent.

Why People Think Schema Boosts AI Citations

The "add schema, get cited" story didn't come from nowhere.

An observational study by Kevin Indig and AirOps, published April 13, 2026, analyzed 16,851 queries run against ChatGPT — producing 50,553 responses and touching 353,799 pages.

Across the pages they analyzed, pages with JSON-LD were cited 38.5% of the time, compared with 32.0% for pages without it—a 6.5 percentage-point gap.

That 6.5-point gap looks like proof. Pages with schema get cited more; therefore schema causes citations. That's the whole pitch, in two sentences.

And it's worth being fair to the AirOps work here, because it wasn't lazy. The researchers compared the schema and non-schema pages on word count, heading count, domain authority, and query-match score — and found the two groups nearly identical on all four, with the JSON-LD citation gap still standing. That's real analytical effort, and it's why the finding is worth taking seriously rather than dismissing as a naive correlation.

But there's still a gap between "held up across measured controls" and "caused the difference." Pages that bother to implement JSON-LD correctly aren't a random sample of the web. They also tend to have cleaner crawlability, more mature editorial processes, and clearer entities overall — and no observational study can control for every one of those at once. Ahrefs said this plainly about its own correlational finding: sites that add structured data "tend to also invest in technical SEO, publish authoritative content, build links, maintain their pages, and rank well in regular search," so cited pages "over-index on all of those signals at once."

So the honest read of the observational evidence is narrower than the pitch: the association was substantial enough to investigate and survived several measured controls, but observational data still can't prove that implementing schema caused the difference. To get closer to that, you need an experiment.

Then Researchers Tested What Happened After Schema Was Added

Ahrefs ran that experiment. Published May 11, 2026, it tracked 1,885 pages that added JSON-LD schema between August 2025 and March 2026, matched against roughly 4,000 control pages that had similar citation levels going in but didn't add schema.

This is a genuinely different kind of evidence than the correlational numbers above. It isolates the variable that actually matters: not "do cited pages tend to have schema," but "does adding schema change what happens next."

The result:

• Google AI Mode: +2.4%
• ChatGPT: +2.2%
• Google AI Overviews: -4.6%

Two of those numbers are noise. In Ahrefs' own framing, the AI Mode and ChatGPT changes were small enough that they "could easily be random noise across thousands of URLs" — both statistically indistinguishable from zero. The AI Overviews decline was small but statistically real relative to the matched control group, and the researchers were explicit that they couldn't confidently attribute it to the schema addition itself. Don't read that -4.6% as "schema hurts your AI visibility." Read it as: something moved, the study can't say what caused it, and it wasn't a validated negative effect of adding markup.

Put together with the section above, this is the article's turning point. Pages with schema are cited more often than pages without it. Adding schema to a page didn't reliably move its citation rate. Both findings can be true — they're answering different questions.

But the Experiment Does Not Answer Everything

Don't let this swing too far toward "schema doesn't matter." The Ahrefs experiment has a real and specific limitation: every page in the study had already received at least 100 Google AI Overview citations before it was studied. These weren't obscure pages hoping to break in — they were already established in the AI citation ecosystem.

That narrows what the study can tell you. It answers one question well: if a page is already visible to these systems, does adding schema increase how often it gets cited? The answer, for these pages, was essentially no. It does not answer a different and arguably more important one: can structured data help a new, obscure, low-authority, or poorly classified page get discovered or understood by these systems in the first place?

That's not a technicality. It's the difference between two genuinely different jobs schema could be doing. The available evidence does not tell us yet whether schema helps a page enter the citation pool at all. That remains plausible, but unproven. No reliable public evidence establishes it either way.

Be comfortable with that. An honest answer here is more useful than a confident one that outruns the data.

What Happens When an AI Fetches a Page Directly?

There's a second experiment worth understanding, and it gets at a different mechanism entirely: what an AI system does the moment it fetches a specific page.

In late 2025, searchVIU built a test page for a fictional product and distributed its prices across different sources — some in visible HTML, some rendered by JavaScript, and some placed only inside the structured-data layer, invisible to a human reader. Then they queried five AI systems — ChatGPT, Claude, Gemini, Perplexity, and Google AI Mode — across eight scenarios and checked which prices each system could recover.

The result that matters here: the price placed only in JSON-LD was recovered by none of the five systems. The same held for prices hidden in Microdata and RDFa — other structured-data formats, tested the same way. When these systems fetched the page live, they read the visible, rendered content. The structured-data-only facts sat there unread.

That's a meaningful finding, but it proves a narrower thing than "AI ignores structured data." searchVIU itself frames its test as one stage of a longer pipeline — training, indexing, search, and direct fetch — and is clear that its experiment primarily measures that last stage, the live direct fetch. searchVIU argues that structured data may still be used earlier in the pipeline, particularly during indexing — that's the authors' interpretation, not something their direct-fetch test demonstrates on its own. It doesn't have to rest on their interpretation, though: Google Search has documented, long-standing processing of structured data during indexing and for search-feature eligibility, independent of anything this experiment tested.

So the safe conclusion is precise: in searchVIU's controlled direct-fetch experiment, none of the five tested systems retrieved facts that existed only inside the structured-data layer. That does not establish whether structured data was used earlier — during crawling, indexing, classification, knowledge-graph construction, or search retrieval. A simplified version of that pipeline looks like this:

Crawling → Indexing / Classification → Retrieval → Direct Fetch → Answer Generation

The direct-fetch test speaks clearly to one stage near the end. It says little about the ones before it, and nobody outside these companies has full visibility into exactly where each platform's systems touch structured data. Claiming certainty in either direction would be a mistake.

What Google Actually Says About AI Search and Schema

Set the experiments aside for a moment and go to the source. Google's documentation on AI features, last updated December 10, 2025, is direct: there are no additional technical requirements to appear in AI Overviews or AI Mode beyond standard Search eligibility, and there's no special Schema.org markup you need to add for those features.

Google went further in May 2026. On May 15, it published a dedicated guide, “Optimizing your website for generative AI features on Google Search,” folding AI optimization directly into its core SEO documentation.

So this isn't Google being vague. Its current guidance is specific: don't overfocus on structured data for generative search, because it isn't required and there's no special AI schema to add — and keep using structured data for the established reasons it already matters in Search. That's a stronger version of the same point, straight from the platform whose features most of this hype is aimed at. "No special AI schema required" is not "structured data is useless"; it's "don't buy a new AI-schema product because AI answers now exist." Standard schema, correctly implemented, still does what it always did.

One note of scope: this is Google's guidance for Google's AI features. Google doesn't claim authority over how ChatGPT, Perplexity, or Claude surface content, and neither does this section.

Microsoft Gives Us an Important Counterexample

If Google is the conservative voice here, Microsoft is the exception — and it's a real one.

Fabrice Canel of Microsoft stated on stage at SMX Munich, reported by Search Engine Land on March 20, 2025, that structured data helps Microsoft's LLMs understand content.

Give that its full weight. It's real evidence, not marketing copy, and it shouldn't be waved away to keep a tidier "schema doesn't matter" story intact. But look closely at what it claims. Canel confirmed schema helps Copilot understand content. No controlled experiment identified for this article shows that schema increases how often Copilot chooses to cite that content. Understanding and citing are two different steps, and Microsoft's statement speaks only to the first.

The honest takeaway isn't "Microsoft proves schema works," and it isn't "Microsoft is the exception that changes nothing." It's narrower than either: different platforms appear to use structured data differently, and a blanket statement about "AI" collapses distinctions that actually matter.

What OpenAI and Perplexity Actually Tell Publishers

For OpenAI, the public guidance covers how publicly accessible sites can appear in ChatGPT Search, the role of the OAI-SearchBot crawler in that discovery, and the controls publishers have over it.

For Perplexity, the documentation covers PerplexityBot's indexing access and Perplexity-User's live-fetch behavior — access controls, not markup parsing.

Two things are true at once here, and they need to stay separate. Undocumented is not the same as unused: silence isn't proof these systems never touch structured data anywhere in their pipelines. But undocumented is also not evidence of a citation lift: publishers currently have no documented basis for the claim that adding schema causes better retrieval or citation inside these systems. That's a meaningfully weaker claim than "OpenAI and Perplexity ignore schema" — and a meaningfully weaker one than "OpenAI and Perplexity use schema for citations," which is exactly the claim a lot of current AEO advice makes without documentation behind it.

So What Does Schema Markup Actually Do?

Step back from the AI-citation question and look at what structured data for SEO actually does, because that job hasn't changed.

Structured data gives you an explicit, standardized way to describe an entity — an Organization, a Person, a LocalBusiness, a Product, a Service, an Article — and the relationships between them. A few properties carry most of the weight. @type describes what kind of entity a node represents. @id provides a stable identifier you can use to connect references to the same entity within a structured-data graph. sameAs provides an explicit, structured relationship to another page or identifier representing that same entity — a Wikidata page, a verified profile.

Be careful about what those properties do and don't do. @id lets you connect nodes cleanly inside your own graph; it doesn't guarantee a search engine adopts it as that entity's canonical identifier. sameAs asserts a relationship to something that represents the same entity; it doesn't prove identity, create authority, generate a Knowledge Graph entry, guarantee recognition, or stand as the only way identity can be resolved. What structured data does, reliably, is state these facts explicitly instead of leaving a machine to infer them from prose.

Google's documentation confirms structured data helps it gather information about the people, organizations, and products a page describes, and it remains tied to eligibility for a specific, documented set of enhanced search appearances — eligibility, not a guarantee of display.

"Having Schema" Is the Wrong Question

This is where the evidence review turns into the work we actually do.

Detecting JSON-LD on a page tells you almost nothing about whether that markup is correct. A site can "have schema" and still be running duplicate Product entities, conflicting Offer prices, availability that doesn't match the actual cart, entity types that don't match what's on the page, or facts that went stale months ago and nobody noticed.

Shopify is a particularly clear example: themes, apps, and custom JSON-LD can all emit overlapping Product or Offer markup on the same template, contradicting each other without anyone realizing more than one source is writing to the page. That specific failure pattern is common enough that we wrote it up on its own in Your Shopify Store's Schema Is Fighting Itself. The same thing happens on WordPress and any plugin-heavy platform where three or four systems can all write structured data to a page without knowing about each other.

The useful concept here is structured-data ownership: which system is actually producing which facts, and can you prove it? "Do you have schema?" is close to a meaningless question — plenty of sites can answer yes and still be shipping contradictions to every crawler that reads the page. The better question is what your structured data actually says, where it's coming from, and whether you can prove it's correct.

What AI Search Readiness Actually Looks Like

There's no clean formula for "AI search readiness," and anyone selling you one is selling you something simpler than the evidence supports. What the research does support is a set of interconnected layers, none of which works in isolation:

1. Accessibility — can search engines and relevant crawlers actually reach the content?
2. Retrieval — can systems discover and pull the right page for a given query?
3. Useful information — does the page contain something specific and accurate worth extracting, or is it padding?
4. Entity and factual clarity — is it obvious who or what the page is actually about?
5. Structured data — are the important facts expressed consistently, in a format machines can parse without guessing?
6. External corroboration — do independent sources support the business, its claims, and its expertise?
7. Validation and maintenance — does the machine-readable version of the site stay correct as the real site changes?

Different systems weight these differently, and nobody outside those companies has full visibility into exactly how much. Worth noting: in the AirOps data, conventional authority metrics like domain authority and backlink count did not positively predict AI citation — retrieval rank and how directly a page matched the query mattered more.

What Businesses Should Actually Do

None of this is a reason to do nothing. It's a reason to do the right things, in the right order, without paying for the wrong ones.

1. Don't rely on a JSON-LD block as the only place a critical fact exists — put the facts that matter in the visible content too.
2. Keep pages crawlable and indexable where that's actually the goal.
3. Publish information that's genuinely yours — first-hand and specific, not a rewording of what ten other sites already say.
4. Keep entity information consistent: the same business name, the same address, the same relationships, everywhere they appear.
5. Implement the structured data that's actually relevant to the page, correctly — not decoratively.
6. Validate it. Don't assume a theme or app got it right on its own.
7. Know which system is producing your markup — theme, app, or custom code — and fix conflicts when more than one is writing to the same page.
8. Keep structured data synchronized with what a human visitor actually sees.
9. Build the independent authority and corroboration that supports the business beyond its own markup, recognizing that different citation systems may weigh those signals differently.
10. Don't buy speculative "AI schema" because someone promised it produces citations. No major platform currently documents a special AI-specific Schema.org markup requirement that produces citations.

That list isn't glamorous. Expose the claim being sold to you. Validate it against what the evidence actually supports. Implement what survives that check. Lock it in with documentation, so it doesn't quietly drift out of sync after the next theme update or app change. The more serious failures are often not missing properties. They're markup nobody has checked since it was installed.

The Honest Answer

Schema markup still matters. Not because sprinkling JSON-LD across a site forces ChatGPT, Gemini, AI Mode, Perplexity, or Copilot to cite it — the best available evidence doesn't support that. It matters because the modern web increasingly runs on systems trying to interpret entities, facts, relationships, products, organizations, authors, and services, and structured data is one standardized way to make some of that explicit instead of implied.

That's a legitimate technical advantage. It doesn't need to be a visibility guarantee to be worth doing correctly.

Clarity is the promise. Citation is not.

If you already know your structured data needs to be built or upgraded — a new site, a platform migration, a service business that's never had proper markup — that's implementation work: architecture, deployment, validation, and documentation, with a clear baseline for future maintenance. Our done-for-you schema implementation covers exactly that.

If you're not sure whether what you already have is correct — or which theme, app, plugin, or custom code is actually producing it — that's a diagnostic question first, not a build question. The Schema Health Review is the starting point for that.