Do AI crawlers render JavaScript? What GPTBot and ClaudeBot see

Most AI crawlers do not render JavaScript: Vercel's study of AI crawler traffic found that GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot and PerplexityBot read only the HTML your server sends, and only Gemini (through Googlebot) and Applebot render pages. If your content appears only after JavaScript runs, those crawlers see an empty page, and one curl command tells you whether that is your site.

That matters because the crawlers that do not render are the ones behind ChatGPT, Claude and Perplexity answers. A page that looks complete in a browser can be blank to all three.

Which AI crawlers render JavaScript?

Vercel measured it on its own network and found that "none of the major AI crawlers currently render JavaScript," naming OpenAI's, Anthropic's, Meta's, ByteDance's and Perplexity's crawlers. Two crawlers render: Gemini, which uses Googlebot's infrastructure, and Applebot, which renders through a browser-based crawler. The table lists each crawler you are likely to care about.

The non-rendering crawlers do download scripts; they just never run them. Vercel found ChatGPT's crawler spent 11.50% of its fetches on JavaScript files and Claude's 23.84%, while ChatGPT's single largest share, 57.70%, went to HTML. The scripts arrive and sit unexecuted, so the content they would have built never exists for the crawler.

Vercel published this in December 2024, and neither OpenAI, Anthropic nor Perplexity documents rendering support on its crawler pages as of September 2026. Test your own pages rather than relying on any list.

What does an AI crawler see on a React or Vite single-page app?

It sees the HTML shell and nothing else. The default React template from Vite serves a body that holds one empty element and one script tag, and a crawler that does not run the script reads a page with no words on it. Every heading, price and paragraph your app renders is added later, by code the crawler never runs.

This is the whole index.html of Vite's React TypeScript template:

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Vite + React + TS</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.tsx"></script>
  </body>
</html>

To GPTBot or ClaudeBot, that page's title is "Vite + React + TS" and its content is an empty <div id="root"></div>. Setting the title from JavaScript after load does not help, because the crawler has already read the one in the file. The same applies to Vue's template, which ships an empty <div id="app"></div>, and to any app built by an AI builder that outputs a client-rendered single-page app. The guide to client-side rendering and SEO covers the pattern across frameworks.

How do you test what an AI crawler sees?

Fetch the page without running JavaScript and search the result for a sentence you can see in the browser. If the sentence is there, the crawlers can read it. If the count is zero, the sentence is built by JavaScript and non-rendering crawlers never see it. The test takes one command per page.

1. Pick a sentence from the body of the page, such as a line from your pricing table.
2. Run: curl -s https://yoursite.com/pricing | grep -c "per seat per month". A result of 1 or more means the sentence is in the raw HTML; 0 means it is not.
3. Repeat with an AI crawler's user agent, in case your server or CDN serves bots something different: curl -s -A "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.4; +https://openai.com/gptbot" https://yoursite.com/pricing | grep -c "per seat per month".
4. Check the page's metadata the same way: curl -s https://yoursite.com/pricing | grep -iE "<title>|name=\"description\"|application/ld\+json".
5. Compare View Source with the browser's element inspector. View Source shows what the server sent; the inspector shows what JavaScript built. Anything only in the inspector is invisible to non-rendering crawlers.

Run it on the pages you most want cited: home, pricing, features, comparisons and documentation. Logged-in app screens do not matter here.

Which parts of the page must be in the raw HTML?

Everything an AI answer might quote or use to describe the page. Vercel's advice for being crawled is to server-render "main content (articles, product information, documentation), meta information (titles, descriptions, categories), and navigation structures." Structured data belongs in the same list, since a crawler that does not run scripts never sees JSON-LD injected by one.

Links deserve a special mention. If your navigation is built by JavaScript, a non-rendering crawler that lands on your home page cannot find your pricing or docs at all, even if those pages are server-rendered.

How do you fix a client-rendered site for AI crawlers?

Send the content in the first HTML response. Three approaches do that: render each page on the server per request, generate pages as static HTML at build time, or prerender specific routes to HTML while the rest of the app stays client-side. For most product sites, prerendering the public marketing routes is the smallest change.

Whichever you pick, run the curl test again after deploying. Frameworks that support server rendering can still ship a page whose main content sits inside a component that only renders in the browser, and the raw HTML is the only honest check. If your site came from an AI app builder, the guide to Lovable SEO and the guide to an AI-built app that isn't indexed cover the builder-specific steps.

What else do AI crawlers struggle with?

Broken URLs and redirects, by a wide margin. The same Vercel study found ChatGPT's crawler spent 34.82% of its fetches on pages that returned 404, and Claude's 34.16%, against 8.22% for Googlebot. ChatGPT's crawler also spent 14.36% of its fetches following redirects. Every wasted fetch is one that did not reach a page you want quoted.

Three fixes cut that waste, and they are the same ones that help Google:

1. Point internal links at the final URL, not at an address that redirects to it.
2. Remove dead and redirected URLs from your XML sitemap, so it lists only pages that return 200.
3. Return a real 404 or 410 for pages that are gone, instead of a 200 page that says "not found," so crawlers can drop them.

Single-page apps are prone to the third problem. A client-side router can serve the same 200 shell for every path, including paths that do not exist, and the "not found" message appears only after JavaScript runs, which a non-rendering crawler never sees.

Does Google's rendering mean you can skip this?

No. Google does render JavaScript, but it is one engine among several, and Google itself recommends not relying on it. Googlebot queues pages for rendering in a headless Chromium after crawling, so content built by JavaScript can be indexed later than content in the HTML, and none of that helps ChatGPT, Claude or Perplexity.

Google's JavaScript guide says "server-side or pre-rendering is still a great idea because it makes your website faster for users and crawlers, and not all bots can run JavaScript." Gemini is the one AI assistant that benefits from Google's rendering, because it retrieves through Google's index. For every other assistant, only the raw HTML counts. The guide to optimizing for AI search covers what to put in that HTML once it is there.

Check your raw HTML the way AI crawlers read it

Running curl on every page takes time, and a deploy can quietly move content back into the browser. Run the free scan on LaunchScaler: it takes a URL, needs no account and runs 156 checks across 6 of its 7 categories at no cost. It flags primary content that is missing from the raw HTML and only appears after JavaScript runs, for both search engines and AI crawlers, and it requests your page as ChatGPT-User and Claude-User to catch an empty client-rendered shell. Its search checks also read the title, meta description, canonical and structured data your server sends.