{"id":1373,"date":"2026-07-16T06:34:52","date_gmt":"2026-07-16T06:34:52","guid":{"rendered":"https:\/\/maxaeo.ai\/blog\/javascript-schema-ai-crawlers\/"},"modified":"2026-07-16T06:34:52","modified_gmt":"2026-07-16T06:34:52","slug":"javascript-schema-ai-crawlers","status":"publish","type":"post","link":"https:\/\/maxaeo.ai\/blog\/javascript-schema-ai-crawlers\/","title":{"rendered":"JavaScript Schema and AI Crawlers: Is Your JSON-LD Actually Retrieved?"},"content":{"rendered":"

Short version: if JavaScript writes your structured data into the page after load, most AI crawlers never see it.<\/strong> That is the JavaScript schema AI crawlers problem in one sentence\u2014and it quietly breaks structured data on a large share of modern sites. GPTBot, ClaudeBot, and PerplexityBot fetch your raw HTML and move on. They do not run your scripts, so any JSON-LD added by a tag manager, a useEffect<\/code> hook, or a hydration step simply isn't there when they read the page.<\/p>\n

This matters because structured data is one of the clearest ways to tell an answer engine what your page is, who published it, and how it connects to your brand. If that signal exists only in the rendered DOM, you are optimizing for a reader that never arrives. Below: how to check what is actually retrieved, why tag managers and hydration fail, and how to fix it\u2014grounded in crawler-traffic data and a controlled test you can reproduce.<\/p>\n

\"Diagram<\/figure>\n

The short answer: most AI crawlers can't see JavaScript-injected schema<\/h2>\n

Most AI crawlers do not execute JavaScript.<\/strong> They read the HTML your server returns and nothing more. If your JSON-LD is added client-side, it is absent from what they retrieve\u2014so it cannot inform how ChatGPT, Claude, or Perplexity describe your brand.<\/p>\n

Vercel's analysis of AI crawler traffic<\/a> found that none of the major AI crawlers\u2014OpenAI's GPTBot, OAI-SearchBot, and ChatGPT-User; Anthropic's ClaudeBot; and PerplexityBot\u2014render JavaScript. They sometimes fetch<\/em> script files (GPTBot in 11.50%<\/strong> of requests, ClaudeBot in 23.84%<\/strong>) but never execute<\/em> them, so they can't read client-rendered content. The meaningful exception is Google: Gemini and Google's AI surfaces lean on Googlebot's infrastructure, which renders JavaScript on a deferred pass.<\/p>\n

So the rule of thumb is blunt. For everything except Google's stack, treat AI crawlers as non-rendering.<\/strong> Whatever isn't in the raw HTML doesn't exist to them.<\/p>\n

What "retrieved" actually means: the three gates your JSON-LD must pass<\/h2>\n

"Retrieved" is not one step\u2014it is three. For structured data to help an AI engine, it must clear three gates: Retrieval<\/strong> (present in the raw bytes), Rendering<\/strong> (built into the DOM), and Reconciliation<\/strong> (valid and parseable). JavaScript-injected schema often clears the last two but fails the first\u2014which is exactly why it looks fine in a browser and vanishes for crawlers.<\/p>\n

This three-gate model is the fastest way to reason about a specific bot. A non-rendering crawler can only ever clear Gate 1. Googlebot can clear all three\u2014but on a delay, and never guaranteed for every URL. Design so Gate 1 always passes, and every downstream engine works.<\/strong><\/p>\n

Gate 1 \u2014 Retrieval: is it in the raw bytes?<\/h3>\n

Retrieval is whether the <script type="application\/ld+json"><\/code> block is physically present in the HTTP response body, before any JavaScript runs. This is the only gate that non-rendering crawlers clear. If your schema isn't in these bytes, GPTBot, ClaudeBot, and PerplexityBot see nothing.<\/p>\n

Gate 2 \u2014 Rendering: is it in the DOM after JS runs?<\/h3>\n

Rendering is whether the block appears once scripts execute and the DOM is built. A tag-manager tag or a hydration effect that injects JSON-LD passes here\u2014which is why it looks correct in your browser's Elements panel and misleads teams into thinking the job is done.<\/p>\n

Gate 3 \u2014 Reconciliation: is it valid and parseable?<\/h3>\n

Reconciliation is whether the JSON is well-formed, uses correct @type<\/code> values, and references entities that resolve. A block can render perfectly and still fail here\u2014duplicate @id<\/code>s, a trailing comma, or a hydration mismatch that ships two conflicting Article<\/code> objects. Clearing Gate 1 is wasted if Gate 3 breaks.<\/p>\n

Which AI crawlers render JavaScript? A decision matrix<\/h2>\n

Here is how the major crawlers behave, and whether client-side JSON-LD reaches them. Use it to decide how much you can rely on JavaScript for a given surface.<\/p>\n\n\n\n\n\n\n\n\n\n\n
Crawler<\/th>\nOperator<\/th>\nRenders JavaScript?<\/th>\nSees JS-injected JSON-LD?<\/th>\n<\/tr>\n<\/thead>\n
GPTBot<\/td>\nOpenAI<\/td>\nNo<\/td>\nNo<\/td>\n<\/tr>\n
OAI-SearchBot \/ ChatGPT-User<\/td>\nOpenAI<\/td>\nNo<\/td>\nNo<\/td>\n<\/tr>\n
ClaudeBot<\/td>\nAnthropic<\/td>\nNo<\/td>\nNo<\/td>\n<\/tr>\n
PerplexityBot<\/td>\nPerplexity<\/td>\nNo<\/td>\nNo<\/td>\n<\/tr>\n
Googlebot (feeds AI Overviews, AI Mode, Gemini grounding)<\/td>\nGoogle<\/td>\nYes (deferred render)<\/td>\nEventually, after render<\/td>\n<\/tr>\n
Bingbot (feeds Microsoft Copilot)<\/td>\nMicrosoft<\/td>\nLimited<\/td>\nUnreliable<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Two nuances matter. Google rendering is not a safety net.<\/strong> It runs on a second, delayed pass subject to crawl budget, and the engines that build their own answers\u2014ChatGPT, Claude, Perplexity\u2014largely rely on their own non-rendering crawlers, not Googlebot. If you want to see which index each assistant actually draws from, our breakdown of which search index powers each AI engine<\/a> maps it engine by engine. Treat any crawler not proven to render as if it can't.<\/p>\n

How to test whether your JSON-LD is actually retrieved<\/h2>\n

The fastest test is to fetch your page the way a non-rendering crawler does and search the raw response for your schema.<\/strong> If it isn't there, AI crawlers can't see it. You need no special access\u2014just a terminal.<\/p>\n

    \n
  1. Fetch the raw HTML.<\/strong> Run curl -sL https:\/\/example.com\/your-page | grep -i "application\/ld+json"<\/code>. Servers return the same bytes to any client, so plain curl<\/code> already shows what a non-rendering bot receives.<\/li>\n
  2. Confirm with a crawler user agent.<\/strong> Repeat with curl -A "GPTBot" -sL ...<\/code> to rule out user-agent-specific delivery. If the result differs, you are cloaking by UA\u2014fix that separately.<\/li>\n
  3. Read the block, not just its presence.<\/strong> Use grep -A 30 "application\/ld+json"<\/code> to print the JSON and eyeball whether it is complete or truncated.<\/li>\n
  4. Render the page and compare.<\/strong> Load the same URL in Google's Rich Results Test<\/a> in URL mode, which renders like Googlebot. Schema that appears here but not in step 1 is JavaScript-injected\u2014visible to Google eventually, invisible to non-rendering AI crawlers now.<\/li>\n
  5. Validate the markup.<\/strong> Paste the block into the Schema.org validator<\/a> to clear Gate 3.<\/li>\n<\/ol>\n

    If step 1 is empty and step 4 shows the schema, the diagnosis is confirmed: your structured data lives only in the DOM. For a deeper, repeatable version of this method across content types, see our repeatable test for whether AI crawlers render JavaScript<\/a>.<\/p>\n

    \"Terminal<\/figure>\n

    What our controlled test found<\/h3>\n

    To make the failure concrete, we built one article page in Next.js and injected the same<\/strong> Article<\/code> JSON-LD three ways: hardcoded in the server HTML, added via a client-side useEffect<\/code> hook, and pushed through a Google Tag Manager custom-HTML tag. We then fetched the URL with a non-rendering user agent and compared it against the Googlebot-rendered DOM.<\/p>\n\n\n\n\n\n\n\n
    Injection method<\/th>\nIn raw HTML (non-rendering crawler)?<\/th>\nIn rendered DOM (Googlebot)?<\/th>\n<\/tr>\n<\/thead>\n
    Hardcoded in server HTML<\/td>\nYes<\/td>\nYes<\/td>\n<\/tr>\n
    useEffect<\/code> client hook<\/td>\nNo<\/td>\nYes<\/td>\n<\/tr>\n
    GTM custom-HTML tag<\/td>\nNo<\/td>\nYes (URL mode only)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    Only the server-rendered variant appeared in the raw bytes. Both JavaScript methods were invisible to the non-rendering fetch and surfaced only once the page was rendered. The takeaway is unambiguous: for retrieval, injection method\u2014not markup quality\u2014decides whether AI crawlers ever see your schema.<\/strong> This holds for every schema type\u2014Organization<\/code>, Product<\/code>, FAQPage<\/code>, BreadcrumbList<\/code>\u2014because retrieval depends on where the markup lives, not on what @type<\/code> it declares.<\/p>\n

    Tag manager failure modes<\/h2>\n

    Google Tag Manager is the most common way JSON-LD goes missing.<\/strong> GTM is a JavaScript container that fires after the page loads, so anything it injects lives only in the rendered DOM. Non-rendering AI crawlers receive the HTML before GTM runs and never see the tag.<\/p>\n

    The failure has several flavors worth naming:<\/p>\n