Schema Markup for AI Search: Does JSON-LD Still Help?

For years the advice has been simple: add JSON-LD and AI will understand you better. A new controlled study published on October 14 puts real numbers on that claim, and the answer is more awkward than most guides on schema markup for AI search admit. Rick Ramos at Serptwerker ran 21,600 model trials and 1,644 live fetches across six models.

His headline finding: at the model level, schema works about as well as an extra sentence of plain text. Whether an AI product even sees your JSON-LD depends on which fetcher reads the page. That changes how you should write and ship structured data.

TL;DR

In the test, JSON-LD and an equal-length prose sentence lifted citation rates by the same amount (odds ratio 0.98).
OpenAI's and Anthropic's web tools returned none of the facts that lived only in JSON-LD, while Google's fetcher passed it through.
Put every key fact in visible HTML first, then mirror it in valid schema that never contradicts the page.

What the schema markup for AI search test found

Ramos built 60 pages for fictional companies, each carrying one fact such as a price, an address or an author. Every fact appeared in five versions: body text only, body plus JSON-LD, body plus a prose sentence of the same length, JSON-LD only (valid or broken), and body and schema that disagreed.

The results, from the published write-up:

Scenario	What happened
Body text only	Cited 70% of the time
Body + JSON-LD	Cited 95%
Body + extra prose sentence	Cited 95%
Schema-only facts via Claude web fetch and GPT-5.5 web search	0 of 100 answered
Schema-only facts via Gemini Flash fetcher	92 of 100 answered
Body and schema disagree (hosted models)	Followed the body 88 to 94% of the time

So the lift was real, but prose gave the same lift. Ramos thinks the gain came from retrieval: FAQPage question wording simply matched the test queries more closely.

The caveats matter

The companies were fictional, each page held one fact, and the consumer app tests were small. Google indexed only 8 of the 60 pages, so the study says nothing reliable about rich results or Google's own index. Treat it as strong evidence about fetchers, not a verdict on schema as a whole.

Why the fetcher decides what AI sees

This lines up with RESONEO's LLM crawler report from January, which found that ChatGPT, Claude, Gemini and Perplexity's user-triggered fetchers don't execute JavaScript, and marked JSON-LD as not directly extracted by the HTML-only fetchers. Google AI Mode was the exception, because it reads from Google's index rather than fetching live.

In practice there are two very different paths into an AI answer:

Index path. Google crawls your page, parses structured data and stores it. AI Overviews and AI Mode can draw on that.
Live fetch path. A user asks ChatGPT or Claude about your page, a fetcher pulls the HTML, strips it to text and hands that to the model. A <script type="application/ld+json"> block often doesn't survive that step.

If your price or opening hours exist only in JSON-LD, the second path may never see them. That's easy to miss, because Google's Rich Results Test will still show everything as valid.

Where structured data for AI still earns its place

None of this means you should rip out your schema. It means you should stop treating it as a hidden channel for facts.

Schema.org's first public usage dataset, built from Google's crawl, shows types like Organization, WebSite and BreadcrumbList on more than 10 million domains, and Product, Article and FAQPage on 1 to 10 million. It's popular because it's unambiguous: a price field is a price, not a number near a currency sign.

Structured data still helps with:

Google's index and rich results, which the study explicitly didn't test.
Disambiguation. sameAs links and @id references tie your brand to one entity.
Agents that act. A browser agent comparing products can read Offer.price and availability without guessing from layout.
Claude's quality filter. In the test, Claude used schema-only facts 96% of the time when the JSON-LD was valid and 56% when it was broken. Broken markup costs you.

The weak spot is drift. When body and schema disagreed, Gemini Pro served a stale FAQPage answer in 8 of 20 tries through Google's fetcher. An FAQ block that your CMS forgot to update is worse than none.

A visible-first JSON-LD pattern

The safest setup puts the fact in the HTML and has schema mirror it. Here's a product page done that way:

<h1>Trailhead 40L Pack</h1>
<p class="price">$149.00 <span>In stock, ships in 2 days</span></p>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Trailhead 40L Pack",
  "offers": {
    "@type": "Offer",
    "price": "149.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}
</script>

Both paths now work. The live fetcher reads "$149.00, In stock" from the paragraph. The index reads the Offer. And because one template renders both from the same data, they can't drift apart.

Avoid the reverse: a price shown only in a client-rendered widget, with JSON-LD as its only server-side home. That works for Google and fails for ChatGPT and Claude users.

Checklist: audit your schema for AI search this week

Find schema-only facts. For your top 10 pages, compare JSON-LD fields with the visible text. Any price, address, author, date or spec that's missing from the body needs to go into the HTML.
Server-render the visible version. Fetchers that skip JavaScript need the fact in the initial HTML response. Test with curl -s https://yoursite.com/page | grep "149.00".
Run a JSON-LD validator on every template. Use the Schema Markup Validator or Google's Rich Results Test, and fix parse errors first. Broken markup was discounted heavily in the study.
Generate schema from the same data as the page. Hand-pasted JSON-LD in a theme file is how drift starts.
Review FAQPage blocks. Delete or update stale answers, and make sure each one matches the visible FAQ word for word.
Keep the basics. Organization, WebSite, BreadcrumbList and the type that fits each page (Product, Article, LocalBusiness) are still worth having.

You can see where you stand quickly: a free AgentReady scan checks structured data (JSON-LD and Open Graph) as part of the Browser Readiness pillar, alongside heading structure and ARIA landmarks that shape what text-only fetchers actually read.

Check your own site

Structured data sits inside Browser Readiness, which carries 40% of the Agent Readiness Score. A low result there usually means missing or invalid JSON-LD, thin Open Graph tags, or weak heading and landmark structure, so agents have to guess from layout. If you want the background on which types matter for agents, read our guide to schema markup for AI agents. A single-page scan is free and takes about a minute. Scan your site free.

Key takeaways

In a controlled test, schema helped AI citation about as much as an extra sentence of visible text did.
ChatGPT's and Claude's fetchers ignored facts that existed only in JSON-LD, while Google's passed them through.
Valid markup matters: Claude discounted broken JSON-LD sharply.
Schema that contradicts the page can surface stale answers, especially FAQPage.
Keep schema for the index, rich results and agents, but never as the only home for a fact.

FAQ

Does schema markup help with AI search?

It helps, but less than many guides claim. In Serptwerker's October 2026 test, adding JSON-LD raised citation rates from 70% to 95%, and adding a plain prose sentence did exactly the same. Schema still feeds Google's index and rich results, so it's worth keeping, as long as every fact also appears in visible text.

Can ChatGPT read JSON-LD on my website?

Often not when it fetches your page live. In the study, OpenAI's web search and Anthropic's web fetch answered none of 100 facts that existed only in JSON-LD. RESONEO's crawler report also found these fetchers don't run JavaScript. Put prices, addresses and specs in server-rendered HTML so any fetcher can read them.

Is JSON-LD still worth it for SEO?

Yes. JSON-LD is how Google reads structured data for rich results and its index, and Product, Article and FAQPage are each used on 1 to 10 million domains in Schema.org's usage data. The study didn't test rich results. The lesson is to keep JSON-LD valid and in sync with the page, not to drop it.

What happens if my schema and page content disagree?

Most hosted models trusted the visible text 88 to 94% of the time, but not always. Gemini Pro served a stale FAQPage answer in 8 of 20 tries through Google's fetcher, and small local models picked the wrong schema value about 40% of the time. Generate both from one data source so they can't drift.

Start with your three most valuable pages: open each one, check that every fact in its JSON-LD is also visible in the HTML, and run it through a validator. Then see how the rest of your site reads to agents. Run a free AgentReady scan.

Schema Markup for AI Search: What a 21,600-Trial Test Found