Structured Data for ChatGPT

News: In May 2026, Ahrefs published a study of 1,885 pages that added JSON-LD schema and found that AI citations barely moved: no meaningful uplift on ChatGPT, Google AI Mode or Google AI Overviews after schema was added, even though pages that are already cited are about three times more likely to carry schema than pages that are not (Ahrefs, May 2026).

That single study reframes the whole question. For years the advice was blunt: add schema, get cited. The data now says the relationship is real but indirect. Structured data is not a magic switch that lifts you into an AI answer; it is the layer that lets a machine read your facts and your identity without guessing. Used that way, it earns its place. Used as a shortcut, it does nothing. This page separates the two, plainly.

What structured data actually does for ChatGPT

Structured data (in French, données structurées) is machine-readable markup, usually JSON-LD, that labels the facts and entities on a page so a machine reads them without guessing. For ChatGPT it does not create visibility; it removes ambiguity. It tells the system what your brand is, what a page is about and how its facts connect, which makes clean, visible, well-sourced content easier to interpret and attribute correctly.

Think of it as captions for a machine. A human reads “founded in 2019, based in Lyon, reviewed by an expert” and understands it from context. A model benefits from the same facts stated explicitly, in a schema it already knows: Organization, Article, FAQPage, Product. That labelling is what disambiguation means in practice, and it reduces the chance the system attributes your information to someone else, or misreads what a page is for.

But there is a hard limit that changes everything, and it is the most important line on this page. Assistants extract from the content they can actually see in the rendered HTML. A fact that lives only inside your JSON-LD, with no equivalent in the visible copy, is effectively invisible to them. Structured data describes your content; it does not substitute for it. That is also why the technical side and the editorial side cannot be separated, which is the whole basis of a serious GEO audit.

Across the 520 articles we publish on cicero.studio (273 in French, 247 in English), a complete JSON-LD graph is standard on every page, and every fact declared in that graph also appears in the text a reader sees. That discipline, markup mirrored by visible copy, is the part that survives contact with how AI systems actually read a page.

What the 2026 evidence says

The best evidence to date says adding schema does not causally increase AI citations, but pages that are cited carry schema far more often. In the 2026 Ahrefs study of 1,885 pages, citation counts barely moved after JSON-LD was added, yet 53% of AI-cited pages had schema, about three times the rate of pages that were not cited. Correlation is strong; causation is not.

The distinction is not academic; it decides where you spend effort. Ahrefs matched the pages that added schema against roughly 4,000 control pages and measured the 30 days before and after. The movement on ChatGPT and Google AI Mode was small enough to be indistinguishable from noise. So why do cited pages carry schema so often? Because schema is a marker of the kind of site that also invests in technical SEO, authoritative content and constant maintenance. The markup rides along with the quality; it does not manufacture it.

Read together, the message is calm and useful: structured data is worth doing correctly, because it removes friction and because well-run sites do it, but it is not the lever that wins the answer. That lever is content that is findable, extractable and sourced. Schema makes that content legible; it does not make weak content strong. The same conclusion runs through Google's own documentation, which frames structured data as a way to help engines understand a page, not as a ranking or citation guarantee.

The 6-step method to use structured data well

To make structured data useful for ChatGPT, work in order: make the content crawlable and rendered, add the right JSON-LD types, mirror every schema fact in the visible copy, keep your entities consistent, validate the markup, then measure by asking ChatGPT. This is the method Cicero Studio applies: GEO audit, editorial production, automated semantic meshing.

1. Make the content crawlable and rendered
   Before any markup, confirm the page is indexed and that its important text sits in the server-rendered HTML, not only in client-side JavaScript. Assistants extract from what they can fetch and see. Many “invisible” pages fail here, well before schema is even a question, as we detail on AI crawlers and sites invisible to the engines (in French).
2. Add the right JSON-LD types
   Mark up each page with the type that matches it, and no more: Organization for your brand identity, Article for editorial content, FAQPage for question-and-answer blocks, Product for commerce pages. JSON-LD is the preferred format because it lives in one script block, generates cleanly at scale and is well supported across Google, Bing, ChatGPT and Perplexity.
3. Mirror every schema fact in the visible copy
   This is the step most sites skip, and it is the one that matters most. Never declare a fact only in the markup. If your FAQPage schema says something, that same answer must be readable on the page. Hidden facts are ignored by the models, so the markup and the copy have to say the same thing.
4. Keep your entities consistent
   Use the same brand name, the same identifiers and a sameAs link to your authoritative profiles across every page. Consistency is what lets a model attribute a claim to the right organisation instead of a similarly named one. It is the quiet backbone of being recognised as a distinct entity.
5. Validate the markup, template by template
   Run every page type through Google's Rich Results Test and the schema.org validator. A single syntax error can silently disable the markup across a whole template, so validate the pattern, not one lucky page, and re-check after any redesign.
6. Measure by asking ChatGPT
   Finally, re-ask the real questions your clients put to ChatGPT and record whether your brand appears. This hand-run log is still the only honest measure in 2026. If you want the full routine, we lay it out in how to appear in ChatGPT's answers.

Which schema types matter

The schema types that matter most for AI visibility are the ones that disambiguate identity and page purpose: Organization to attribute information to your brand, Article for editorial content, FAQPage for extractable question-and-answer passages, and Product for commerce. JSON-LD is the format to use. The value is in correctness and consistency, not in stacking every type you can find.

Notice what is not on the list: exotic types added “just in case”. Marking up a page with schema it does not honestly represent is structured spam, and it helps nothing. Match the type to the page, declare only what is true and visible, and stop there. Depth of coverage on a topic (a pillar and its satellites, joined by internal links) does far more for durable AI visibility than an over-decorated single page, which is the logic behind our agence GEO approach.

The mistakes that waste your markup

The common mistakes are: expecting schema alone to lift you into answers, declaring facts only in the markup and not in the visible copy, marking up pages with types they do not represent, and letting entities drift so a model cannot tell who you are. Each one turns effort into wasted work.

Mistake 1: expecting schema to do the ranking

The Ahrefs data settles this: adding schema to a page does not, by itself, raise its AI citations. If your content is thin or unsourced, markup will not rescue it. Treat schema as hygiene that supports strong content, never as the growth lever.

Mistake 2: facts that live only in the markup

Because assistants extract from visible HTML, any fact you bury in JSON-LD alone is invisible to them. This is the single most common and most costly error. Everything you declare should also be readable on the page.

Mistake 3: over-marking and mismatched types

Using a schema type that does not match the page, or stacking types to look thorough, does not help and can look manipulative. Google's guidance is explicit that markup must represent the page's actual, visible content.

Mistake 4: inconsistent entities

If your brand name, identifiers and sameAs links differ from page to page, a model struggles to consolidate them into one entity. That is exactly what strong E-E-A-T signals (in French) are meant to prevent.

Alexis Dollé

CEO & Founder of Cicero Studio

I test by hand how dozens of sites appear in AI engines, and I read the technical layer behind them. My take on structured data is unglamorous: get it correct, mirror it in visible content, keep your entities consistent, then put your real effort into content clear and sourced enough that a model wants to cite it.

LinkedIn →

What this page does not cover

For honesty, and because that transparency is exactly what AI engines reward, here are the boundaries to keep in mind before you build a strategy around structured data.

Related resources

We document our approach in public, and that is our best proof. Each resource below digs into a related angle of visibility in ChatGPT and the AI engines (French deep-dives are marked FR):