JSON-LD for AI Search: What It Does and Doesn't Do

JSON-LD does not unlock AI search on its own: Google states that AI Overviews and AI Mode need no special schema.org markup, and OpenAI, Anthropic and Perplexity have published nothing that says structured data makes a citation more likely. What JSON-LD does well is describe a page's type, author, dates and publisher in a way machines cannot misread. That only helps if the markup is in the HTML your server delivers and matches what the page visibly says.

What Google says about structured data and AI features

Google's documentation on AI features is unusually direct. There are "no additional requirements to appear in AI Overviews or AI Mode", you "don't need to create new machine readable files, AI text files, or markup", and "there's also no special schema.org structured data that you need to add" (Google Search Central: AI features and your website). The same fundamentals as for regular search apply: the page must be crawlable, indexable and eligible for a snippet.

That does not make structured data pointless. Google still uses it to understand what a page is about and to power specific result types (Google: Introduction to structured data markup). It just means that anyone selling JSON-LD as a switch for AI answers is promising more than the evidence supports.

JSON-LD in Google vs. in AI assistants

"AI search" covers very different systems. The difference matters for what you can expect from markup:

System	What is documented	What it means for JSON-LD
Google Search, AI Overviews, AI Mode	Structured data helps Google understand pages and enables some rich results; no special markup for AI features	Useful for clarity and eligible rich results, not a separate AI ranking lever
ChatGPT search, Perplexity, Claude	No public statement on how, or whether, structured data is used	Treat any claimed citation boost as unproven
Crawlers that do not execute JavaScript	Several AI crawlers fetch JavaScript files but do not run them (Vercel analysis, December 2024)	Markup injected in the browser is invisible to them

Our view: the practical value of JSON-LD for AI systems is disambiguation, not a bonus. A language model can read a well-written article without markup. What markup adds is certainty about facts that are otherwise scattered or ambiguous: who wrote this, when it was last changed, which company is behind it, and whether "Mercury" is a planet, a bank or a band.

What JSON-LD adds that plain text often doesn't

• Page type: Article, Product, Organization, Event or SoftwareApplication, stated rather than guessed.
• Authorship: a Person with a profile URL and sameAs links, connected to the article.
• Freshness: datePublished and dateModified in a fixed format.
• Entity links: nodes in one @graph connected by @id, so article, author, organization and website clearly belong together.

The stronger lever for being quoted is still the visible text: direct answers under clear headings, sources, and statements that can stand on their own. JSON-LD supports that text. It cannot replace it.

FAQ and HowTo markup: what changed

Many JSON-LD guides still promise FAQ dropdowns and step snippets in Google. That is out of date. Google dropped HowTo rich results in 2023, and FAQ rich results no longer appear in Google Search since May 7, 2026 (Google Search Central: documentation updates). FAQPage markup can still describe a page's questions and answers, but it no longer produces a visible search feature. If a guide's main argument for FAQ schema is the rich result, discount the rest of its advice accordingly.

Schema types worth maintaining

Pick a small set you can generate automatically and keep correct:

Type	Use it for	Key properties
Organization	Your brand as one entity, defined once	name, url, logo, sameAs, @id
WebSite	The site as a whole	name, url, publisher
Article / BlogPosting	Editorial content	headline, author, datePublished, dateModified, publisher
Person	Authors	name, url, jobTitle, sameAs
BreadcrumbList	Where the page sits in your structure	itemListElement
Product / SoftwareApplication / Service	Offer pages	name, description, offers (only with real, visible data)

Connection beats volume. An article whose publisher points via @id to the same Organization node as every other page describes your brand consistently. Ten isolated blocks with slightly different company names do the opposite. A compact example:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Inc.",
      "url": "https://example.com/",
      "sameAs": ["https://www.linkedin.com/company/example"]
    },
    {
      "@type": "BlogPosting",
      "headline": "Your article title",
      "datePublished": "2026-02-15",
      "dateModified": "2026-09-28",
      "author": { "@type": "Person", "name": "Jane Doe", "url": "https://example.com/team/jane-doe" },
      "publisher": { "@id": "https://example.com/#organization" },
      "mainEntityOfPage": "https://example.com/blog/your-article"
    }
  ]
}

Place it in a script element with type="application/ld+json", in the head or the body. Both work. More on typical mistakes in 8 schema errors that confuse AI search engines.

Can AI crawlers see your JSON-LD at all?

This is the point most JSON-LD guides skip. Many sites add markup with JavaScript: through Google Tag Manager, a consent tool, an SEO plugin that runs client-side, or a single-page app framework. Googlebot renders JavaScript, so Google usually sees it. Other crawlers may not. An analysis by Vercel (December 2024) found that the crawlers of OpenAI, Anthropic, Perplexity, Meta and ByteDance fetch JavaScript files but do not execute them, while Google's crawler for Gemini and Applebot do render (Vercel: The rise of the AI crawler). Crawler behavior may have changed since, but it is the best public data available.

The consequence: markup that only exists after the browser runs your scripts does not exist for those crawlers. The same applies to content. Background and fixes are in Make JavaScript sites accessible to AI crawlers.

A 10-minute check: what each crawler receives

1. Raw source, not the DOM: open "View page source" (not DevTools, which shows the rendered DOM) and search for application/ld+json. Only what appears there is served by your server.
2. Fetch as several bots: run the same request with different user agents and count the JSON-LD blocks:

   for ua in "GPTBot" "OAI-SearchBot" "ClaudeBot" "PerplexityBot" "Googlebot"; do
     printf "%s: " "$ua"
     curl -s -A "$ua" https://example.com/your-page | grep -c "application/ld+json"
   done

   A 0 means no server-side markup for that request. Different counts per bot point to user-agent-dependent delivery or blocking at the CDN or firewall.
3. Compare with Google's rendered view: the Rich Results Test shows rendered markup. If Google finds blocks your raw source lacks, they are created by JavaScript.
4. Validate syntax and types: the Schema Markup Validator also checks types for which Google offers no rich result.
5. Check access: markup is useless if robots.txt or a bot filter locks the crawler out. The AI crawler check shows which bots may fetch your page.

If markup is client-side only, move it into the server template, the static build or your CMS's server-side output.

JSON-LD, Microdata or RDFa?

Google supports all three formats and recommends JSON-LD because it can be maintained separately from the visible HTML (Google: supported formats). For AI assistants there is no documented difference between formats. If your site already has valid, server-rendered Microdata, rewriting it purely "for AI" is hard to justify. For new work, JSON-LD is the easier choice: one block, easy to generate, easy to test.

Keeping JSON-LD correct over time

• Generate it from the CMS: headline, author and dates should come from the same fields as the visible text. Hand-copied markup breaks at the first redesign.
• Only mark up what is visible: ratings, prices or questions that do not appear on the page violate Google's structured data guidelines and make the page contradictory.
• One Organization, one @id: identical name, logo and profiles on every page.
• Set dateModified honestly: on real content changes, not on every build.
• Re-test after template changes: one missing comma invalidates the whole block.

If you want markup, crawler access and quotable content reviewed together and prioritized, that is what a GEO audit covers.

Frequently asked questions

Do you need JSON-LD to appear in Google AI Overviews?

No. Google states that there are no additional requirements for AI Overviews or AI Mode and no special schema.org structured data you need to add. The same fundamentals as for regular search apply.

Do ChatGPT and Perplexity use structured data?

OpenAI and Perplexity have not published how, or whether, they use structured data. A crawler that reads your raw HTML will find server-rendered JSON-LD, but there is no documented citation advantage.

Can AI crawlers see JSON-LD added with JavaScript or Google Tag Manager?

Often not. A Vercel analysis from December 2024 found that the crawlers of OpenAI, Anthropic and Perplexity do not execute JavaScript, so markup created in the browser is invisible to them. Googlebot renders JavaScript.

Should JSON-LD go in the head or the body?

Both are valid. What matters is that the script block is part of the HTML your server delivers and is not created later in the browser.

Does Google still show FAQ rich results?

No. FAQ rich results no longer appear in Google Search since May 7, 2026, and HowTo rich results were dropped in 2023. FAQPage markup can still describe the content but no longer produces a visible search feature.

Is JSON-LD better than Microdata for AI search?

There is no documented difference for AI assistants. Google supports JSON-LD, Microdata and RDFa and recommends JSON-LD because it is easier to maintain separately from the visible HTML.

How do I test my JSON-LD?

Check the raw page source or a curl request for application/ld+json, use Google's Rich Results Test for rendered markup and rich result types, and the Schema Markup Validator for all other schema.org types.