A SaaS company’s product pages carry full Product and FAQ schema. Open the page in a browser, right-click, and “view rendered source” shows it clean. Run it through Google’s Rich Results Test and it passes without a warning. Ask ChatGPT about the product line, and it has never heard of the pricing tiers described in that schema. The reason sits between the browser tab and the server response: the structured data was injected by client-side JavaScript, and most AI crawlers never execute a single line of it.
Key Takeaways
- Googlebot renders JavaScript before indexing, but most AI crawlers fetch only the raw HTML response and never execute scripts.
- Schema visible in browser dev tools or a “view rendered source” panel proves nothing about what an AI model actually retrieves.
- The only reliable audit is comparing what a raw HTTP request returns against what the browser renders after JavaScript runs.
Why Your Schema Renders Fine and Still Does Not Count
Every modern browser runs a full JavaScript engine. Load a page, and the browser fetches the HTML, then executes any scripts that build out the DOM, including scripts that inject JSON-LD schema blocks after the fact. What you see in the browser, or in a “view rendered source” tool, is the finished product: HTML plus everything JavaScript added on top of it.
That finished product is not what most crawlers receive. A crawler makes an HTTP request, gets back whatever the server sends in that single response, and moves on. If your schema exists only because a script built it client-side, it exists in the browser’s memory, not in the bytes the server actually sent. Rendering correctly for a human visitor tells you nothing about what arrives at that first request.
Googlebot Renders JavaScript. Most AI Crawlers Do Not
Google runs a two-wave indexing process. The first wave crawls raw HTML immediately. The second wave, sometimes delayed by days, sends the page through a headless Chromium instance that executes JavaScript and captures the result. Schema injected client-side gets picked up eventually, in that second wave, which is why it can pass Google’s testing tools even when it is technically fragile.
AI crawlers were not built for that two-wave model. GPTBot, ClaudeBot, and PerplexityBot are built to fetch enormous volumes of pages quickly, and running a full browser instance for every page multiplies cost and latency by orders of magnitude. Most of them issue a plain HTTP GET, read the response body, and parse whatever HTML is actually there. No rendering queue, no second pass. If the schema was not in that first response, it does not get a second chance.
growth in AI brand presence for NewDay USA, tracked weekly across five engines over six months, after fixing exactly this class of retrieval gap.See the case study
If a crawler never executes JavaScript, structured data that exists only after the page renders does not exist at all, no matter how correctly it renders for everyone else.
What Each AI Crawler Actually Fetches
The engines behave differently enough that a blanket assumption is a mistake. ChatGPT pulls from across the open web through its own crawling and indexing infrastructure, largely on the strength of raw page fetches rather than rendered sessions. Gemini cross-references Search, YouTube and Scholar, which means it can inherit some signal from Google’s own rendered index, but its dedicated crawler still behaves as a lightweight fetcher on most sites.
Claude leans on high-authority publications and documentation, and ClaudeBot reads the raw HTML response directly. Perplexity cites its sources inline, which makes its crawler particularly dependent on structured facts being present and parseable in that first response, since it is extracting specific claims to attribute in real time. Grok reads the real-time social web and weighs schema less heavily overall, but the underlying fetch behavior is the same: no browser, no script execution.
How to Check What Is Actually in the Raw HTML Response
Stop trusting anything you see through the browser’s inspector or a “view rendered source” extension. Both show you the DOM after JavaScript has run, which is exactly the version an AI crawler will not see. The audit has to happen closer to the wire.
- Request the page with a plain HTTP tool such as curl, with no browser and no JavaScript engine involved, and search the returned body for application/ld+json.
- Use your browser’s actual “view page source” command (not the inspector panel) on the same URL. It shows the server response before any script executes, and it is the closest browser-native equivalent to what a fetcher receives.
- Crawl the site with a tool capable of rendering disabled, and diff the output against a rendering-enabled crawl of the same URLs. Any schema that appears only in the rendered version is invisible to most AI crawlers.
- Check server logs for known AI crawler user agents and confirm the response served to them matches the raw HTML you tested, not a cached rendered snapshot.
If the schema block does not show up in any of the first three checks, it is not reaching the models building answers from your site, regardless of how it tests in Google’s tools.
Fixing It: Move Schema Into the Server Response
The direct fix is to stop generating JSON-LD in client-side JavaScript and generate it on the server instead, so it ships as part of the initial HTML. Frameworks with server-side rendering or static generation, such as Next.js or Nuxt, can output the schema block at build time or request time, before anything reaches the client. The content is identical. Only the point at which it gets written changes.
Where a full framework migration is not realistic in the near term, a smaller fix works: keep the rest of the page client-rendered, but have the server template inject the JSON-LD block directly into the HTML it sends, independent of the JavaScript bundle. This is a template-layer change, not an architecture change, and it closes the gap for the schema specifically without touching how the rest of the page behaves.
What To Do This Week
Pick your ten highest-value pages, the ones most likely to be cited when someone asks an AI model about your product or category, and run a raw curl request against each one. Note which schema types are present in that response and which only appear after rendering. That list is your priority queue.
Fix the template layer for those pages first, re-run the same curl check to confirm the schema now ships in the initial response, and only then move on to the rest of the site. Citations compound once a model starts pulling from a page, so the pages worth fixing first are the ones already close to being cited, not the ones furthest behind.
FAQs
Does Googlebot Rendering My Schema Mean AEO Is Already Fine?
No. Google’s rendering pipeline eventually executes JavaScript and picks up client-side schema, but most AI crawlers do not run a rendering pipeline at all. Passing Google’s Rich Results Test only confirms behavior for Google Search, not for ChatGPT, Claude, or Perplexity.
Which AI Crawlers Execute JavaScript?
None of the major ones do this as standard practice. GPTBot, ClaudeBot, and PerplexityBot are built for high-volume, low-latency fetching, which means they request raw HTML and do not run a browser engine to build out the final DOM.
Is Server-Side Rendering the Only Fix?
Full server-side rendering is the most complete fix, but it is not the only one. Injecting the JSON-LD block directly at the server template layer, even while other page elements remain client-rendered, closes the same gap without a full architecture change.
How Do I Know if My CMS Injects Schema via JavaScript?
Run a curl request against a page and search the response for application/ld+json. If it is missing there but visible in your browser’s inspector or a rendered source viewer, your CMS or tag manager is adding it client-side after the page loads.
