Whether a program that fetches a web page performs JavaScript rendering can decide whether it receives the page’s full content or only part of it. A web page first arrives from the server as HTML—text with markup for headings, paragraphs, and links. A browser builds the visible page from it and, along the way, runs the JavaScript the page brings with it. That JavaScript can insert, change, or load more content. The browser keeps the current state of the page in the Document Object Model (DOM), a model of the page in memory that scripts can change at any time.

Delivered HTML and the finished page

An example shows the difference. If the HTML the server delivers contains a paragraph with the text “Price: €49,” every program that fetches the page receives the price. If the HTML only contains an empty paragraph at that spot, which a script fills with the price in the browser, only programs that run this script see the price. Programs that read only the delivered HTML get the empty paragraph.

Some websites go further: they deliver an almost empty HTML document and build text, images, and links entirely in the browser. This approach is called client-side rendering because the page is only built on the client—the program that fetches it. In a browser, such a page looks exactly like one whose content is already in the HTML. The difference only shows for programs that don’t run JavaScript.

Who runs JavaScript and who doesn’t

According to Google, not all bots—programs that fetch web pages automatically—can run JavaScript. Some providers document how they handle JavaScript:

  • Google: Googlebot puts fetched pages in a queue. Once Google’s resources allow, a headless browser renders the page and runs the JavaScript. This is a browser without a visible window—in Google’s case, one based on Chromium, the open-source basis of Chrome. For the AI features in Google Search, such as AI Overviews, Google writes that it can process content within JavaScript as long as it isn’t blocked.
  • Microsoft: Bing’s Webmaster Guidelines, which also cover Copilot, ask site owners to let Bingbot crawl and render content efficiently and advise against hiding critical content behind client-side rendering. According to Microsoft, content that cannot be reliably rendered may not be indexed or selected as a source for AI answers.
  • Apple: Applebot, which collects content for Siri, Spotlight, and other Apple features, can render websites in a browser, according to Apple.
  • Anthropic: According to Anthropic (as of October 2026), the web fetch tool that developers use to let their own Claude-based AI applications fetch web pages does not support websites built dynamically with JavaScript. For pages that need a real browser, Anthropic points to a separate browser tool.

OpenAI, Anthropic, and Perplexity say nothing in the documentation of their AI crawlers about whether these crawlers run JavaScript. An analysis that the hosting provider Vercel published as a blog post with the agency MERJ in December 2024 observed that the crawlers it tested from OpenAI, Anthropic, and Perplexity, as well as from Meta and ByteDance, did not execute JavaScript; the crawlers from OpenAI and Anthropic fetched JavaScript files but did not execute them. The measurements were taken mainly on Vercel’s own network, and Vercel itself offers server-side rendering. This is a snapshot by a third party, not a statement by the providers; crawlers may have changed since.

AI agents that work on a person’s behalf in a real browser are a different case: there, the browser runs the JavaScript, just as it does for a person in front of the screen.

Content that loads on scroll or click

Even a crawler that runs JavaScript doesn’t necessarily see everything. Some websites load content only when it is needed: more products once someone scrolls to the end of a list, or the text of a tab only after a click. This deferred loading is called lazy loading. According to Google, Google Search, whose index Google’s AI features also draw on, does not interact with a page: it doesn’t scroll or click. Google therefore recommends loading content not in response to scrolling or clicking but as soon as it is in the visible area of the browser window, and giving each chunk of an endlessly loading list its own persistent URL.

The lazy loading for images that browsers provide themselves is different: the image is already in the delivered HTML, and the browser only delays loading the image file.

How to check what arrives without JavaScript

The page source, which desktop browsers can display, shows the HTML the server delivers. If you find an important sentence, a price, a phone number, or a link there, it is in the delivered HTML. If it is missing, it is only created by JavaScript. The page source shows what your browser receives, though: servers that deliberately treat crawlers differently, for example through bot management, can deliver something else to them. The page source is easy to confuse with the Elements panel in Chrome’s developer tools, which shows the DOM—the page after JavaScript has changed it. Alternatively, you can turn off JavaScript for a tab in the developer tools; whatever is missing after reloading the page depends on JavaScript.

Why JavaScript rendering matters for GEO

AI systems that draw on web content for their answers read pages through AI index crawlers, which collect pages for an index in advance; through user-triggered fetchers, which fetch a page when a person using an AI system asks a question, shares a link, or assigns a task; or through Googlebot and Bingbot, whose indexes Google’s AI features and Copilot also use. Because not every provider documents whether its programs run JavaScript, only content in the delivered HTML is certain to reach all of them. If service descriptions, prices, or contact details are missing there, an AI system whose programs don’t run JavaScript cannot use them for its answer; it may then describe an offering incompletely or rely on other sources.

Whether a crawler is allowed and able to fetch a page at all is a matter of crawlability. JavaScript rendering is about whether the fetched content is complete. The reliable way to make important content available to every program is to write it into the HTML on the server. How that works is covered under server-side rendering.