
Ultra guide to rendering in Google: what Googlebot runs, when it takes the snapshot and how to check it
How Google really renders: WRS, render queue, the 5-second mystery, viewport, noindex, CSR and SSR, Bing and AI.

What Google does with your page from the moment it crawls it until it indexes it: how it renders it, how long it waits, what it sees and what it doesn't, and how to check it on your own site. With tests you can repeat, the 5-second mystery explained and what happens outside Google, with Bing and AI.
Google doesn't index the HTML you write. It indexes the DOM that is left after loading your page in its own browser, running your JavaScript and applying your CSS. Almost everything that is hard to explain in an audit comes from that difference: the noindex nobody added, the text that is on the page and Google doesn't see, the Search Console screenshot with a huge block where an article should be.
I've been writing about this since 2023 and running my own tests: counters, made-up meta tags, pages with pixel markers. In this guide I bring together what I've learned from them, what Google documents and what others have measured, in an order that makes sense from start to finish: first what rendering is, then what Google does with your page and, finally, how to check it on yours.
It's long. If you only want to audit your site, go straight to the checklist.
The short version
- Google indexes the rendered HTML: the DOM as it stands after your JavaScript has run. What the script adds counts just like what came from the server, and what the script removes disappears.
- It renders every page that returns a 200 and doesn't carry a noindex, whether or not it has JavaScript, and it almost always does so seconds or minutes after crawling it.
- According to published tests (Google doesn't document it), it takes the snapshot when its clock reads about 5 seconds, but that clock isn't yours: whatever you delay with a timer longer than 5 seconds is left out, and whatever takes long because an API is slow can make it in.
- It doesn't click or scroll, and it remembers nothing between one load and the next. To see what's further down it stretches the window, which is why a block set to 100vh (as tall as the window) with no cap stretches with it.
- Before rendering, it has already read the server HTML, with its status code, its noindex and its canonical. A noindex that comes in there can't be removed with JavaScript, and with the canonical it's better not to take the risk.
- Outside Google, almost nobody runs your JavaScript. In my tests, Bing's index doesn't reflect what the script changes, and most AI chats read only the HTML when you give them a URL. An AI browser does run it, because it's a browser.
- Everything is checked in the same place: Search Console's URL Inspection, "View crawled page". If your content is in that HTML, Google has it.
Six words you're going to read a lot
- Initial HTML (or source code): what your server sends. It's what you see with Ctrl+U.
- DOM: the tree the browser builds from that HTML and that JavaScript can change. It's what you see in the element inspector.
- Rendered HTML: the DOM turned back into HTML at a given moment. It's what Google indexes.
- WRS (Web Rendering Service): Google's service that opens your page in a headless Chromium, runs the JavaScript and returns the rendered HTML.
- Snapshot: the moment the WRS considers the page finished and keeps the DOM. It isn't an image.
- CSR and SSR: rendering in the user's browser (client-side) or on the server (server-side). What matters for SEO is who builds the HTML and when.
What is known for certain, what is disputed and what is worth reviewing
Not all the data going around about rendering is equally reliable. In this table, "known for certain" means Google documents it or several independent tests have measured the same thing; "disputed" means there are serious sources that disagree or a published test is missing; and "worth reviewing" means the data comes from a single test, an old test or something that changes fast.
| Data point | What is known | Status | Where it comes from |
|---|---|---|---|
| What Google indexes | The rendered HTML: the DOM that is left after running the JavaScript, not the source code | Known for certain | Google documentation |
| Which pages it renders | The documentation and Zoe Clifford (2024) say all those that return 200 and don't carry a noindex, whether or not they have JavaScript. Martin Splitt said in 2023 that, if they've already detected that a page is bad, they skip rendering | Disputed | Google documentation and Search Off the Record (2024) versus the Duda webinar (2023); measurement by Vercel and MERJ |
| Wait between crawling and rendering | Seconds or minutes for the vast majority of pages. The medians given range from 5 seconds (Google, verbally) to 10 (an external measurement) | Known for certain | Google; Vercel and MERJ |
| The slowest 10% of that wait | Minutes according to Google; about 3 hours at the 90th percentile and about 18 at the 99th according to an external measurement | Disputed | Google versus Vercel and MERJ |
| When it takes the snapshot | When its internal clock reaches about 5 seconds. That clock stops while it waits for the network and runs fast when the page is doing nothing: a timer longer than 5 seconds is left out and a slow API can make it in | Worth reviewing | My tests, Dave Smart's and Tony McCreath's (Website Advantage). Google doesn't document it |
| Maximum wait in real time | About 30 seconds in real indexing and about 50 in the live test. Google doesn't give the figure | Worth reviewing | Tests by Dave Smart and Tony McCreath |
| JS and CSS cache | Up to 30 days, ignoring your cache headers | Known for certain | Google (Crawling December) |
| How much Googlebot downloads | 2 MB per URL and per resource, measured uncompressed and including the HTTP headers (64 MB for PDFs). Whatever comes after that doesn't exist | Known for certain | Googlebot documentation (3 February 2026) and Gary Illyes's post (31 March 2026); it warns that it may change |
| Clicks, scroll and state | It doesn't click or scroll and doesn't keep cookies or storage between loads | Known for certain | Google documentation |
| How it sees what's further down | It enlarges the window (viewport expansion) instead of scrolling | Known for certain | Google; measured by Tony McCreath |
| Window and screenshot dimensions | 981 × 1742 px at the start on mobile and over a million pixels tall in one test. The Search Console screenshot cuts off at 1750 px | Worth reviewing | Tony McCreath; my test with Mario Mangas |
| Hero at 100vh without max-height | It stretches with the window and distorts the screenshot. That it also harms indexing hasn't been proven | Disputed | My experience on projects versus Google |
| Removing a noindex with JavaScript | It doesn't work. Adding it with JavaScript does | Known for certain | Google; test by Dave Smart |
| Is a page with noindex rendered? | Google "may" skip it, and it has been seen running JavaScript on noindex pages. Most often it isn't, especially if it has always been noindex | Worth reviewing | Documentation (since December 2025); test by Dave Smart |
| Canonical to another URL in the initial HTML | Google only says that conflicting canonicals, or ones changed by JavaScript, can lead to unexpected results. In my experience, the page doesn't even get rendered | Disputed | Documentation versus my experience, with no published experiment |
| Links that only exist through JavaScript | They are discovered later, especially on new sites. An up-to-date sitemap greatly reduces the difference | Known for certain | Onely; Vercel and MERJ |
| Dynamic rendering | Google advises against it: it's a patch, not a solution | Known for certain | Google documentation |
| Web workers | A simple worker was rendered; those that requested data or took longer than a second were not | Worth reviewing | Dave Smart's 2021 test, not repeated |
| Bing | It says it renders. In my tests, its index doesn't reflect changes made by JavaScript | Disputed | Bing guidelines versus my test |
| AI chats when you give them a URL | Most read only the HTML. Qwen ran the JavaScript; DeepSeek, Kimi and Mistral, sometimes | Worth reviewing | My tests (June 2026) |
| AI crawlers | They download the JS files but don't run them. The exception is AppleBot; Gemini is a separate case | Worth reviewing | Vercel and MERJ (December 2024) |
| AI browsers and agents | They open the page in a real browser, so the JavaScript runs. I've only tested one | Known for certain | Google; my test with the Claude Code browser |
| AI Overviews and AI Mode | They retrieve pages from Google's index: if your page is indexed and the property isn't excluded from AI features in Search Console, they can use it | Known for certain | Google documentation; Search Console help (control rolled out on 31 August 2026) |
Each row is explained in its own chapter:
- What rendering is and why the HTML you write isn't the one that counts
- How Google renders: from the crawl queue to the WRS
- What Google sees and what it doesn't: clicks, scroll, window, resources and cache
- The initial HTML rules: noindex, canonical, status codes and soft 404
- The 5-second mystery: how long it takes and how long Google waits
- Rendering strategies: CSR, SSR, static, ISR, hydration and dynamic rendering
- Changing what Google reads without touching the site's code
- How to check what Google has rendered
- Outside Google: Bing, AI chats, their crawlers and AI browsers
- Checklist to audit your site's rendering
- Open questions
What rendering is and why the HTML you write isn't the one that counts
The HTML that gets written isn't the HTML the user ends up seeing. Along the way there may be a CDN, a CMS, a server-side language or a piece of JavaScript that changes everything.
Rendering is the process of turning HTML into pixels.
That's the definition Martin Splitt opened his talks with at SEO on the Beach 2023 and at Andalu-SEO 2026. A search engine, however, cares little about pixels: what interests it is what the browser builds along the way, and you're going to see it step by step.
From HTML to DOM
Neither browsers nor Google read the HTML as it is. They turn it into a tree of nodes, the DOM, and work with that tree (I explained it more calmly in SEO rendering).

The same document as text and as a DOM tree. The browser works with the tree, not with the text.
The DOM is the model the browser builds of the page: it's constructed from the HTML and picks up everything JavaScript changes afterwards. One way to see it is as a recipe. The HTML, the CSS and the images are the ingredients, the browser does the cooking and the DOM is the batter the pancakes come out of.
A house helps to understand something else: why the same code doesn't always produce the same page. If you describe it as if it were HTML, with two floors, three windows and a chimney, it looks like this:
<house floors="2">
<window />
<window />
<window />
<chimney />
</house>Give that description to ten people and they'll draw ten different houses, all of them correct. The same happens with a website: the same code produces different results depending on the device, the screen size or the orientation. There's no such thing as "the page" as something fixed. There's code and what each browser, or each bot, builds with it.
The DOM keeps no trace of whether a piece of content came in the initial HTML or was injected by JavaScript, and that saves a lot of arguments: if it's in the tree when Google takes the snapshot, it's indexable and can rank.
The journey inside the browser, in five steps
The DOM is just one stop. From the moment the HTML arrives until you see something on screen, the browser goes through five steps:
- Parsing: it reads the HTML and CSS it has received.
- DOM and CSSOM: with the HTML it builds the DOM and with the CSS its equivalent for styles, the CSSOM.
- Render tree: the combination of DOM and CSSOM, with only what is going to be seen.
- Layout: it works out where each thing goes and how big it is on screen.
- Painting: now, finally, the pixels.
On a real website these steps can be seen in the Chrome DevTools performance panel, each with its own colour:

The DevTools performance panel. Blue: HTML loading and parsing. Yellow: JavaScript execution. Purple: style calculation and layout. Green: painting.
In this example the JavaScript creates more HTML, which is why blue appears again after the yellow. Behind it comes a purple block of about 700 milliseconds: the browser recalculating styles and putting each thing in its place. That block isn't necessarily JavaScript's fault. A page without a single line of JS can produce a similar chart if the HTML and CSS are badly designed.
Which part of that journey does Google keep? The content and the geometry. To index, as Martin Splitt explained at Andalu-SEO 2026 (the organisers published a summary and the slides), it uses the DOM, which tells it what's there, and the render tree with its layout, which tells it how big each thing is and where it sits. It doesn't need the pixels from the last step.
That's why the snapshot Google takes is of the DOM, not an image. What gets indexed is the rendered HTML. The screenshot Search Console shows is made for us to look at. When that snapshot is taken is worth a whole chapter: the 5-second mystery.
Source code versus final DOM: look at it on your own site
You can see both HTMLs in ten seconds. The first is the source code: press Ctrl+U or type view-source: in front of the URL. It's what the server has sent, before anything runs.

The source code (Ctrl+U) of an Ahrefs blog article: what the server sends.
The second is the final DOM: right-click, "Inspect" and the Elements tab. It's the live tree, with everything JavaScript has added, removed or changed since the HTML arrived.

The same page in the element inspector: the DOM after the JavaScript has run.
There's a small example in the screenshot. The reading progress bar carries a style="width: 13.3312%", a value nobody writes by hand with four decimal places: a script keeps changing it while I scroll.
The quick test is to search for a sentence from your main content in the source code. If it isn't there but it is in the inspector, JavaScript is putting it in, and for Google to read it you depend on it being rendered.
Bear in mind that the DOM in your inspector is your browser's, with your screen, your cookies and your clicks. The one Google has built can only be seen in Search Console's URL Inspection; how to read it is in the tools chapter.
Client and server: who runs what (and why Java isn't JavaScript)

The server sends HTML, CSS, JS and media. What happens next depends on the browser.
The server always sends the browser the same things: HTML, CSS, JS and media files. What changes is who has done the work before they arrive.
Server-side languages (PHP, Python, .NET, Ruby, Java, Liquid on Shopify) run on the hosting machine. They do their part of the rendering there and the browser receives code that has already been processed. That's why you'll never see PHP in your Ctrl+U: you'll see the HTML PHP has generated.
JavaScript acts afterwards and somewhere else. The HTML arrives, the HTML tells the browser to run the scripts and these start modifying the HTML itself. I call it a "patch language". And whoever runs it is the visitor on their phone or computer, or the bot that crawls. Crawling a website that depends on JavaScript takes considerably longer than crawling one that doesn't, and time means resources and money.
And here's the usual clarification: Java isn't JavaScript. Java is just another server-side language, one of those that deliver the HTML already built. JavaScript is the only programming language browsers read, process and run. The name is similar because back in the day JS wanted to ride on Java's popularity, but they're as different as Romanian and Romani.
JavaScript can also work on the server, with Node.js or with a framework that renders there (SSR); you'll see it in the rendering strategies.
Template plus data
It doesn't matter whether you use WordPress, Shopify or a custom build: a website is templates and data. Think of a product page. The template is the same for every product and the data lives in a database. Someone has to put them together, and it can happen at three moments: before anyone requests the page, on the server when the request arrives, or in the user's browser with JavaScript. WordPress puts them together on the server with PHP; a JavaScript framework that renders on the client (CSR), in the browser.
Rendering, for SEO, is deciding where, when and how they're put together. The later and further from the server it happens, the more you depend on whoever visits the page, person or bot, running the JavaScript properly, and the further your Ctrl+U drifts from your final DOM.
How Google renders: from the crawl queue to the WRS
Googlebot isn't a browser that comes into your site, looks around and leaves, but a chain of queues and services in which the browser only appears in one of the links. And it's only the Search client within a shared crawling platform that Google Shopping or AdSense also go through, each with its own user-agent and its own limits.
Having this map in your head clears up a lot of misunderstandings: that Google chooses what it renders, that your server's cache is in charge, that what you see in your Chrome is what it sees.
A URL's journey, step by step
- Discovery. The URL arrives through links, sitemaps or Search Console.
- Crawl queue. Before requesting anything, Googlebot checks the host's robots.txt. If the URL is blocked there's no HTTP request and the journey ends there.
- Crawling. It downloads the HTML and nothing else, as a highly optimised
curlwould, and stores the response with its timings, its headers and the IP. - Processing. The status code and the canonical are evaluated, and the links are extracted from the
hrefattributes and go back to the crawl queue. - Render queue. Pages that have returned 200 and don't carry a noindex go in.
- WRS. When Google's resources allow it, a Chromium without an interface (headless) opens the page and runs the JavaScript.
- Back to processing. The rendered HTML is the one that gets indexed, and links are extracted from it again for the crawl queue.

My own diagram, based on Jan-Peter Ruhso's illustration. It's a rough guide, not an official Google diagram.
The official diagram, more concise, is in Google's JavaScript documentation. Mine has more boxes than Google documents, and the exact order of some of them (where a soft 404 is detected, for example) isn't confirmed. Take it as a map, not a blueprint: some steps happen at the same time and some are repeated.
That Chromium has been evergreen since 2019: it's updated shortly after each stable Chrome release. Before that, Googlebot rendered with an engine that was years old, and a lot of advice that no longer applies comes from that period.
The WRS within the indexing system
Google's indexing is a set of services that talk to each other, each with its own job: crawling, robots.txt parsing, link analysis, content analysis, duplicate removal and rendering. The system processes many websites at once, and a URL can drop out along the way with an error code while the one next to it carries on.
The Web Rendering Service (WRS) is the service that receives the already crawled HTML and its resources, and returns the rendered DOM.

Google slide, from Martin Splitt's talk at SEO on the Beach 2023.
That DOM is the one you see in Search Console's URL Inspection and the one Google uses to index. Internally, the WRS has two parts: the core that renders and a resource cache. The cache is what lets it cope with the volume of websites it processes every day, and also the source of many of the differences with your browser.
Behind it there's a fleet of browsers:

Google slide, from Martin Splitt's talk at SEO on the Beach 2023.
An orchestration layer distributes the work, another instruments the browsers and another collects metrics; a manager (Pool Manager) keeps a pool of headless Chrome instances running. If an instance crashes, it starts another and relaunches the job (it's explained in the SEO on the Beach 2023 talk), so a render isn't left half done because of a browser failure. In 2023 I wrote that this was used to detect cloaking, and I was wrong: relaunching a job that has failed has nothing to do with rendering the same URL several times to compare.
And what if the render still fails? It's rare, and in that case Google keeps the server HTML, which is better than nothing. When it does fail, it's usually because of resources blocked in robots.txt or edge cases, according to the measurement by Vercel and MERJ.
How the WRS differs from your Chrome
The WRS is Chromium, but it doesn't behave like the Chrome you have open:
| What | Your Chrome | The WRS | Source |
|---|---|---|---|
| Network | The browser downloads each resource. | It doesn't go out to the network: it asks Googlebot for each resource. | Splitt and Illyes, Crawling December (3 December 2024) |
| Cache | It obeys your HTTP cache headers. | Its own JavaScript and CSS cache of up to 30 days, regardless of those headers. | Crawling December (2024) |
| State | It keeps cookies, Local Storage and Session Storage. | Stateless: it clears them between one load and the next. | JavaScript troubleshooting guide (updated 18 December 2025) and Illyes (2026) |
| Images and video | It downloads them. | It doesn't request them. Nor fonts. | Illyes (31 March 2026) |
| Shadow DOM | Separate trees. | It flattens shadow DOM and light DOM in the rendered HTML. | JavaScript documentation (updated 4 March 2026) |
| Randomness and clock | Math.random() different on each load and real time. | Math.random() always returns the same sequence and the clock is manipulated. | Tony McCreath's experiment, from Website Advantage (tests from early 2025) |
The first difference is the hardest to take on board. Since the WRS doesn't go out to the network on its own, Googlebot requests every JS and every CSS file: it respects robots.txt and spends crawl budget from the hostname that hosts the resource. That's why considerably more time can pass between one step and the next than in a browser.
The second means that for the WRS your Cache-Control isn't in charge (what to do about it is in the 30-day cache). And "stateless" means that for Google it's always your first visit: if the content depends on a cookie or on something stored in Local Storage during a previous load, it won't see it.
The last one, randomness and the clock, isn't documented, but it has been measured (this test goes into detail). The most reasonable explanation is that Google wants two renders of the same page to give the same result, and that manipulated clock is what explains the 5-second mystery.
The 2 MB limit and the order within the HTML
If the figure of 15 MB rings a bell, it's the one that used to appear in the documentation. Google changed it on the Googlebot page on 3 February 2026, and on 31 March Gary Illyes explained how those bytes are counted. These are the numbers:
- Googlebot downloads at most 2 MB per URL, PDFs aside. The limit applies to the uncompressed data (not to what travels with gzip or Brotli) and includes the HTTP headers.
- For PDFs the limit is 64 MB.
- Any other Google crawler that doesn't declare its own limit uses 15 MB by default.
- Image and video crawlers have thresholds that vary by product.
When an HTML file exceeds 2 MB, Google doesn't reject the page: it cuts the download there and hands that chunk to indexing and to the WRS as if it were the complete file. Whatever comes after isn't downloaded, rendered or indexed.
Each resource the WRS requests has its own 2 MB counter, independent of the HTML. They don't add up, but they aren't exempt either: the documentation applies the same limit to each resource as to the HTML, and Illyes's post warns that the WRS only runs the code the crawler managed to download. A JavaScript bundle over 2 MB would arrive truncated.
The vast majority of websites aren't affected by this: 2 MB of HTML is a huge amount. What does depend on you is the order. What pushes content below the cut-off is embedded base64 images, huge blocks of inline CSS or JavaScript and megabytes of menus at the start of the document. Hence two rules:
- Heavy CSS and JavaScript go into external files, which are downloaded separately and have their own limit.
- Critical things go at the top: title, meta tags, canonical,
linkelements and the essential structured data. If they fall below the cut-off, for Googlebot they don't exist.
Google warns that the limit may change.
Does Google render every page?
That's what the documentation says: all those that return 200 and don't carry a noindex, whether they have JavaScript or not. And Zoe Clifford, from the rendering team, said it on Search Off the Record on 11 July 2024, when asked how they decide which pages to render: "We just render all of them as long as they're HTML". Nor are there sites that get rendering "switched off" for weeks: everything goes into the queue, according to Martin Splitt in the interview with Olga Zarr in May 2024.
An external measurement backs it up. Vercel and MERJ analysed more than 100,000 Googlebot requests, almost all on nextjs.org, and every indexable HTML page with a 200 code ended up rendered, including one without JavaScript. Its scope is limited (one month, practically a single site, and it's signed by a company that sells hosting for JavaScript frameworks), but it points in the same direction as Google.
Google, however, has said both things. A year before Clifford, in the Duda webinar of 23 August 2023, Martin Splitt explained that they run quality control in several phases and that, if they've already detected earlier that a page is bad, they skip rendering: "what's the point?". The documentation goes with Clifford. I work with that version, but I don't consider Splitt's refuted, which is why the table at the start marks this data point as disputed.
There are two documented exceptions, and Google words them conditionally:
- With a code other than 200, for example a 404, rendering might be skipped.
- With a noindex in the meta tag or in the header, Google may skip rendering and JavaScript execution. "May" isn't "always": I go into it in the noindex at source.
A resource blocked by robots.txt isn't a third exception: the page is rendered without it, with whatever that entails.
What is clear is that when Google renders your page and how often it comes back depend on how interested it is in your page. If the quality filter Splitt talked about in 2023 also exists, it affects pages that already had a bigger problem than rendering. According to Martin Splitt in the 2024 interview, if a page takes much longer than usual to be processed, it's usually a sign that Google isn't very interested in that content (you'll see it in the render queue).
What Google sees and what it doesn't: clicks, scroll, window, resources and cache
Google captures the DOM that is left after loading the page without touching anything. It doesn't click, it doesn't hover, it doesn't scroll and it remembers nothing from one visit to the next.
That doesn't mean it only sees what appears on screen. What is in the HTML, even if it's hidden, and what the JavaScript fetches on its own during loading, does go in. With every piece of content you have to ask yourself the same question: is it in the DOM without anyone doing anything?
No clicks or interaction: tabs, accordions and paywalls
Googlebot doesn't click or interact with anything: not tabs, not "see more" buttons, not cookie banners. The most practical test I know of on this is MERJ's 12 experiments with tabbed content: a page Google had never seen, with Bootstrap tabs and a unique sentence for each way of inserting the content, checked in 2018 and again in 2021.
| How the content arrives | 2018 | 2021 |
|---|---|---|
| Static HTML in the visible tab (exp. 1) | Indexed | Indexed |
| Static HTML in a hidden tab (exp. 2) | Indexed | Indexed |
| Text fetched by AJAX from an external API during loading (exp. 6) | Indexed | Indexed |
| Initial HTML replaced by that AJAX (exp. 5) | No | No |
| Text from a JS dictionary on the page itself, inserted on load (exp. 4) | No | No |
| Initial HTML that dictionary was supposed to replace (exp. 3) | Indexed | Indexed |
| Text that only arrives with an onClick, from internal JSON or from an API (exp. 8 and 10) | No | No |
| Static HTML that click would have replaced (exp. 7 and 9) | Indexed | Indexed |
iframe with index,follow (exp. 11) | Indexed | No |
iframe with noindex,nofollow (exp. 12) | No | No |
It boils down to three rules:
- Static HTML is indexed even if the tab is hidden.
- Content that arrives by AJAX during loading is too, and Google keeps the final result.
- What depends on a click doesn't exist for Google: it keeps what was there before the click.
The table has two odd results I wouldn't take as a rule: the text that came from a JavaScript dictionary on the page itself wasn't indexed, and the iframe with index,follow stopped being indexed in 2021. It's a single test page, checked with site: and not with URL Inspection. What it does make clear is that, if something matters to you, it's better for it to be in the HTML.
What Google does simulate is idleness. Googlebot's browser pretends to be idle so that the events waiting for that moment fire, such as requestIdleCallback (Zoe Clifford said so on Search Off the Record on 11 July 2024: "we fake being idle every once in a while"; I wrote about it in Googlebot fakes idleness to render). What you hang on an idle event may run; what you hang on a click won't.
For collapsible content there's a native alternative that doesn't depend on JavaScript: details and summary. The text is in the HTML from the start, the browser takes care of opening and closing it, and it works in every browser:
<details>
<summary>Pregunta que ve el usuario</summary>
<p>Respuesta que ya está en el HTML aunque esté plegada.</p>
</details>The paywall issue comes from this same rule. If you send the full article from the server and hide it with JavaScript until the user proves they're subscribed, the content is in the DOM and Google sees it, as does anyone who disables JavaScript. Google's documentation warns about it: it isn't a reliable way of restricting access. The full content should only come from the server once the subscription is confirmed.
Googlebot doesn't scroll: it enlarges the window
Googlebot doesn't scroll or fire scroll events. Google says so and it has been checked from inside the page by listening for that event: it never arrives.
So how does it see what's further down? By enlarging the window. Google calls it viewport expansion (they explained it in episode 96 of Search Off the Record): the renderer keeps stretching the window, mostly in height, so that whatever only happens when an element enters the screen is triggered. That's why Google reads what is below the first screenful without ever having scrolled down.
How tall is that window? There are three figures that tend to get mixed up, and the first to mix them up was me, when I wrote that Google renders "with exactly 1750px of height":
| Measurement | Figure | Who and how | What it means |
|---|---|---|---|
| Initial window of mobile Googlebot | 981 × 1742 px (innerWidth × innerHeight) | Tony McCreath, reading it with JavaScript from the page itself (Chrome 131) | The height used to calculate the first layout on his test page |
| Screenshot cut-off in the tools | 1750 px in the Search Console viewer; 10,000 px in the Rich Results Test as desktop | Me, at Mario Mangas's suggestion (June 2025) | How far the image they show you goes, not what Google processes |
| Height after resizing | 1,251,074 px | Tony McCreath: two resize events, at around 5 s and 5.3 s on the internal clock | How far the window stretched on a page he made grow non-stop |
The initial window depends on the scale the browser declares, so with a different viewport configuration the number could be different. The final height comes from a page its author made grow non-stop, and Google hasn't published any figure. The screenshot is a limit of the tool, and it's explained in the tools chapter. What all three share is the idea: a very tall window and no scrolling.
Lazy loading and infinite scroll: by visibility yes, by scroll no
A rule for lazy loading follows from the above. The kind that fires when an element becomes visible works, because when the window is stretched everything ends up visible. The kind that listens for the scroll event doesn't, because that event never arrives.
This, for example, Google won't run:
// Loads more products when scrolling down: depends on the scroll event
window.addEventListener('scroll', () => {
if (window.scrollY + window.innerHeight > document.body.offsetHeight - 300) {
cargarMasProductos();
}
});This it will, because it's based on visibility:
<!-- Images and iframes: native lazy loading -->
<img src="/img/producto.webp" loading="lazy" width="600" height="400" alt="…">
<!-- Content: a sentinel element at the end of the list -->
<div id="centinela"></div>
<script>
new IntersectionObserver((entradas) => {
if (entradas[0].isIntersecting) cargarMasProductos();
}).observe(document.getElementById('centinela'));
</script>It's what Google's documentation on lazy loading asks for: load the content when it's visible in the viewport and don't depend on user actions.
Even so, in an infinite scroll listing don't count on Google loading more than a few batches: in one published test there were two window resizes and the DOM ended up with three "pages". The safe approach is for each batch to have its own persistent URL (?page=2), for those URLs to be linked to each other with normal links and for the URL to be updated with the History API as you go.
With images, what you check is that the URL ends up in the src attribute of the <img> in the rendered HTML. During the render, the WRS doesn't even download images or videos: it's enough for it to know where they are.
The 100vh nightmare: a hero without max-height
A rendering problem doesn't always come from JavaScript. Sometimes it comes from a single line of CSS. vh is viewport height: an element with 100vh measures 100% of the window height. It's very common to give it to the first block on the page so the hero takes up the whole screen:
.fullheight {
height: 100vh;
}In your browser it looks fine. In Googlebot the window already starts very tall and then grows, and the hero grows with it until the renderer gives up and stops stretching. You can have all the content in the HTML, without depending on JS for anything, and still show Google a page that looks empty. This is what it looks like in Search Console's "View tested page":

A hero with 100vh in the Search Console screenshot.
There's no text in sight: only the hero background, stretched out of all proportion. It also happened to Pandora's page when I ran it through the Rich Results Test:

Pandora's page in the Rich Results Test.
With dvh (the "dynamic" height unit, which adjusts when the mobile browser bars appear and disappear) the same happens if there's no max-height.
Does it affect indexing or just the preview?
Nobody disputes that the screenshot comes out distorted. What is disputed is whether it also harms indexing or rankings:
- My experience. I've seen quite a few sites with this problem improve almost instantly when it was fixed, and I maintain that it can end in thin content and even in soft 404 (I wrote about it in The hidden SEO risk of using vh units), in "Crawled - currently not indexed" and in products or listings that stop being relevant. It's consulting experience, with no published case, and on paper it shouldn't have an effect.
- What Google says. When asked about this very thing on Search Off the Record, the answer was that they'd have to look into it, because there have been some changes, but that they don't think it's necessarily a problem, since the text is still in the DOM. Even so, they recommend setting a maximum height.
There's an argument in favour of it mattering: Google doesn't index only the DOM, but also the geometry of the render tree, the size and position of each thing. If the layout places your text thousands of pixels below an empty block, it's plausible that this counts even though the text is in the DOM. For established brands, authority makes up for it; on a normal project I wouldn't count on that. I still need to publish a case with before and after data, and I'll add it here if I get permission to show it.
The fix: max-height
Everyone agrees on the remedy, and it's one line of CSS:
.fullheight {
height: 100vh;
max-height: 800px;
}The 800 px is an example; set a reasonable maximum for your design. If you prefer, you can apply it only on narrow screens:
.fullheight {
height: 100vh;
}
@media only screen and (max-width: 800px) {
.fullheight {
max-height: 800px;
}
}The hero gets a height limit without hurting the design, and you don't need to settle the debate to act.

The same website after adding the max-height. The screenshot is censored for privacy, but you can see that the text is now visible.
To check it, run the URL through the Search Console live test, or through the Rich Results Test if the site isn't yours, and look at the screenshot. For this problem the screenshot is useful, because that's exactly where you see the stretched hero. But it's only the symptom: what counts is that the content is in the rendered HTML.
Pseudo-elements: text that is seen and doesn't count
CSS can also be used the other way round: to show users text without it counting as text. What you insert with ::before or ::after is seen on screen, but it isn't in the DOM, so rendering doesn't pick it up. Nor does it appear in search result snippets, without needing a data-nosnippet.
.etiqueta::before {
content: "#";
}They checked it live on Search Off the Record, and talked about the case of a website that drew the hash sign of its hashtags this way: for Google they were just words. For decorative things (an icon, a tagline you don't want Google to read) it's perfect. For content you want to rank, don't use it.
What the WRS doesn't support
The WRS is an up-to-date Chromium, but it lacks things any user's browser has. Google documents what it doesn't do:
- It declines permission requests (camera, location, notifications). If the content only appears after accepting, Google doesn't see it.
- It only speaks HTTP. It doesn't support WebSockets or WebRTC, so whatever arrives that way needs an HTTP alternative.
- It doesn't support WebGL. Whatever you draw with WebGL is either skipped for Googlebot or prerendered on the server.
- It keeps nothing between loads: Local Storage, Session Storage and cookies are cleared from one page to the next.
- It doesn't reliably resolve fragments used as routes (
#/productos). To change view, use the History API. - It flattens the shadow DOM and the light DOM. A web component that doesn't use
slotmay not show what you expect in the rendered HTML.
To that list I'd add web workers: in the only published test, whatever depended on them almost never made it to the rendered HTML.
Blocked resources: the simplest and most repeated mistake
The most common mistake with JavaScript is still overdoing robots.txt and blocking files needed for rendering. Google doesn't render JavaScript from blocked files, and if the WRS can't get a critical resource, it may have trouble extracting the content and getting the page to rank.
The API your JavaScript pulls from counts just like the JS and CSS: if the endpoint is blocked, the script runs but the content doesn't arrive. This robots.txt, which looks cautious, leaves a CSR store without products for Google:
User-agent: *
Disallow: /api/
Disallow: /assets/js/Not everything Google stops requesting is a problem. Its browser cancels on its own whatever is no use to it: fonts, media, URLs that return 404 and analytics events. Seeing resources that didn't load in URL Inspection isn't serious in itself. What's serious is if among them is something your content depends on.
Cache of up to 30 days, fingerprinted files and CDN
The WRS tries to cache all the JS and CSS of the pages it renders and keeps them for up to 30 days, ignoring your cache headers (they explained it in Crawling December). For crawl budget it's good news: there's no need to worry too much about what rendering costs. But it has a flip side: if you change the contents of a file without changing its name, Google may keep rendering with the old version for weeks.
The solution is to put a fingerprint of the content in the file name, as almost all bundlers do:
<!-- Bad: the name doesn't change even if the file changes -->
<script src="/js/main.js"></script>
<!-- Good: the fingerprint only changes when the content changes -->
<script src="/js/main.2bb85551.js"></script>When the file changes, the URL changes and Google's cache invalidates itself. Beware of the opposite extreme: a parameter that changes on every deploy or every request (main.js?v=1717171717) forces Google to request everything again even though nothing has changed, and that's wasted crawl budget. The fingerprint has to come from the file's content.
On CDNs: Google once recommended hosting resources on another hostname to shift crawl budget consumption there, and qualified it a few days later. The extra connection to another domain can slow the page down, so it doesn't recommend it for critical JS and CSS but does for large non-critical files, such as videos or downloads.
For Google, a link is an <a> with href. Injecting it with JavaScript isn't a problem, as long as it's a real link:
<!-- Google follows it -->
<a href="/zapatillas/running/">Running</a>
<!-- Google doesn't follow these: they aren't links -->
<span onclick="location.href='/zapatillas/running/'">Running</span>
<button onclick="irA('running')">Running</button>
<a href="javascript:irA('running')">Running</a>What can happen is that Google finds something that looks like a URL in the code, even if it isn't in a link, and sends it to be crawled: Vercel and MERJ saw URLs discovered inside a JSON and, in their test, whether the URL was in a link or in a JSON didn't change the priority with which Google crawled it. So don't rely on Google finding loose strings for your internal linking, and don't assume that a URL written inside a script won't be crawled.
JavaScript redirects work: the WRS follows them like a normal browser, and Google itself used them when migrating its blog from Blogger. But they take longer, because an HTTP redirect is resolved during crawling and the JavaScript one has to wait for rendering. If you can choose, use a server redirect.
What happens when JavaScript touches the noindex, the canonical or the status codes is the subject of the next chapter.
The initial HTML rules: noindex, canonical, status codes and soft 404
Before rendering anything, Google has already decided things based on the HTML that comes out of your server. The final DOM still counts, but there are signals that are read during crawling, such as the status code, the meta robots and the canonical, and if they say "no" there, whatever your JavaScript does afterwards arrives late or not at all.
The rule of this whole chapter is one: the initial HTML has to be indexable already. The rest are nuances, and some have changed in the last year.
What Google looks at before sending the page to be rendered
Googlebot stores the HTTP response with its headers and passes it to the indexing system. The first thing checked is the status code: 3xx codes are resolved during crawling itself, 4xx codes abort indexing (except 429, which Google treats as a server error) and 5xx codes are treated as a temporary failure until the next crawl. With a 200 it still checks whether the page is a disguised error, the good old soft 404. The noindex and the canonical are evaluated too. Rendering comes afterwards.
Noindex at source: from "it isn't rendered" to "it may not be rendered"
For years the rule was categorical: Google doesn't render noindex pages. It was what was documented and what was measured: with noindex in the initial HTML, the page wasn't rendered and the JavaScript that was supposed to remove it never even ran. It makes sense, because rendering is expensive and a page that isn't going to be indexed doesn't need it.
In 2025 the picture changed. Dave Smart published Noindex No Longer Means Not Rendered with four test pages, each with a fetch to an endpoint that logs who requests it:
| Test page | Did Googlebot run the fetch? | Status in Search Console | Last crawl |
|---|---|---|---|
| Meta robots noindex that the JavaScript itself removes | Yes, via POST | Excluded by noindex | 20 May 2025 |
| X-Robots-Tag: noindex header | Yes, via POST | Excluded by noindex | 22 June 2025 |
| 404 status code | No | Not found (404) | 22 June 2025 |
| Meta robots noindex with JavaScript redirect | Yes, via POST | Excluded by noindex (the destination remained a URL unknown to Google) | 22 June 2025 |
On the three noindex pages Googlebot ran the JavaScript, and all three stayed excluded. The request arrived via POST, which suggests it came from rendering and not from Google seeing something URL-like in the HTML and requesting it just in case. It's a test site, it isn't known whether it's a bug or something intentional, and it may be reverted.
A year earlier, Vercel and MERJ had measured the opposite. In their 2024 study, pages with noindex in the initial HTML weren't rendered, whatever JavaScript they had, and the script that removed the noindex never even ran. Both observations can be true at the same time: something changed between April 2024 and May 2025, or it depends on the site. What won't do is keeping one and keeping quiet about the other.
In December 2025 Google changed its documentation, and today it says that on finding a noindex it "may" skip rendering and JavaScript execution. On the same page there's still another sentence saying that pages with noindex aren't queued for rendering, so the documentation itself isn't entirely consistent. With noindex in the initial HTML, Google may not render the page. Don't take either one or the other for granted.
Removing a noindex with JavaScript doesn't work; adding one does
What hasn't changed: a noindex at source can't be removed with JavaScript. In the test above, the script that removed the noindex did run, and the page stayed excluded. And if the noindex comes in the X-Robots-Tag header, there isn't even a debate: JavaScript can't rewrite an HTTP header.
The other way round does work. If the initial HTML is indexable and the JavaScript adds a noindex, the page ends up out of the index. That's why a noindex can be implemented from Google Tag Manager.
That said, it isn't always immediate: a page with a lot of quality content may first be indexed with the server HTML, without the noindex, and not drop out of the index until the rendered version is processed. That transition can last from a few hours to a few days. The clearer the signals from the server, the less you depend on that back-and-forth.
The noindex flash: when a noindex slips in mid-load
There's a rare case that fits here and that I gave a name to at the time. The symptom: in Search Console the page shows as excluded by a meta noindex, you click "Test live URL" and it's set to index. You check the source code and the DOM, and it's set to index. What could have happened?
A noindex flash is a noindex that appears for an instant in the DOM while the page is being rendered and then disappears.
It can happen above all on websites built with JavaScript frameworks: the server doesn't send any meta robots, the framework ends up setting it to index and, along the way, a noindex slips in. That Google keeps precisely that momentary noindex is a hypothesis of mine: no documentation says so, I have no figures and I haven't published a real case. It seems plausible to me because what counts is the DOM at the moment of the snapshot and a noindex added by JavaScript does work; what nobody has proven is that Google actually captures that intermediate state.
What is certain is the remedy: if the correct meta robots already comes from the server, the risk disappears at the root.
Before blaming the flash, rule out two other explanations for the same symptom:
- That the indexed version is from a crawl before a change you made. Check the date of the last crawl in URL Inspection: the inspection shows what Google saw, and the live test what it would see now.
- That the real Googlebot rendered with old JavaScript from its cache, which the live test doesn't use.
Once that's ruled out, use the method I published in Checking for noindex flashes. Open DevTools, go to Sources > Snippets and save this script as a new snippet:

DevTools in Sources > Snippets, with the script saved as a snippet.
(() => {
console.clear();
const log = (etiqueta, msg, color = 'inherit') =>
console.log(`%c${etiqueta} ${msg}`, `color:${color}; font-weight:bold;`);
let metaObserver = null;
let canonicalObserver = null;
let headObserver = null;
// Observer for meta robots
const startMetaObserver = (meta) => {
log('[VISTO]', `Detectado <meta name="robots"> con contenido inicial: ${meta.getAttribute('content')}`, '#aaf');
if (metaObserver) metaObserver.disconnect();
metaObserver = new MutationObserver((mutations) => {
for (const mutation of mutations) {
if (mutation.type === 'attributes' && mutation.attributeName === 'content') {
const oldValue = mutation.oldValue;
const newValue = meta.getAttribute('content');
const time = new Date().toLocaleTimeString();
log('[CAMBIO]', `[${time}] META robots cambiado`, '#ffcc00');
console.log(' ▸ Anterior:', oldValue);
console.log(' ▸ Nuevo:', newValue);
console.trace(' Origen del cambio');
}
}
});
metaObserver.observe(meta, {
attributes: true,
attributeFilter: ['content'],
attributeOldValue: true
});
log('[OK]', 'Observando cambios en el contenido del meta robots', '#0f0');
};
// Observer for canonical
const startCanonicalObserver = (canonical) => {
log('[VISTO]', `Detectado <link rel="canonical"> con href inicial: ${canonical.getAttribute('href')}`, '#aaf');
if (canonicalObserver) canonicalObserver.disconnect();
canonicalObserver = new MutationObserver((mutations) => {
for (const mutation of mutations) {
if (mutation.type === 'attributes' && mutation.attributeName === 'href') {
const oldValue = mutation.oldValue;
const newValue = canonical.getAttribute('href');
const time = new Date().toLocaleTimeString();
log('[CAMBIO]', `[${time}] CANONICAL cambiado`, '#ff69b4');
console.log(' ▸ Anterior:', oldValue);
console.log(' ▸ Nuevo:', newValue);
console.trace(' Origen del cambio');
}
}
});
canonicalObserver.observe(canonical, {
attributes: true,
attributeFilter: ['href'],
attributeOldValue: true
});
log('[OK]', 'Observando cambios en el href del canonical', '#0f0');
};
// Wait for both elements to appear
const waitForElements = () => {
const existingMeta = document.querySelector('meta[name="robots"]');
const existingCanonical = document.querySelector('link[rel="canonical"]');
if (existingMeta) {
startMetaObserver(existingMeta);
}
if (existingCanonical) {
startCanonicalObserver(existingCanonical);
}
if (existingMeta && existingCanonical) {
return;
}
if (!existingMeta) {
log('[ESPERA]', 'Esperando a que aparezca <meta name="robots">...', '#999');
}
if (!existingCanonical) {
log('[ESPERA]', 'Esperando a que aparezca <link rel="canonical">...', '#999');
}
headObserver = new MutationObserver((mutations) => {
for (const mutation of mutations) {
for (const node of mutation.addedNodes) {
if (node.tagName === 'META' && node.getAttribute('name') === 'robots' && !metaObserver) {
log('[OK]', `Detectado nuevo <meta name="robots"> añadido al DOM: ${node.getAttribute('content')}`, '#0f0');
startMetaObserver(node);
}
if (node.tagName === 'LINK' && node.getAttribute('rel') === 'canonical' && !canonicalObserver) {
log('[OK]', `Detectado nuevo <link rel="canonical"> añadido al DOM: ${node.getAttribute('href')}`, '#0f0');
startCanonicalObserver(node);
}
}
}
// If both observers are active, disconnect the headObserver
if (metaObserver && canonicalObserver) {
headObserver.disconnect();
}
});
headObserver.observe(document.head, { childList: true, subtree: true });
};
waitForElements();
})();It's a self-executing function that clears the console and creates three MutationObservers: one watches the meta robots content, another the canonical's href and the third waits for those two elements to appear in the head if they don't exist yet. For each change it writes the time, the previous value, the new one and a console.trace with the script that caused it.
Once it's saved, go to the Network tab and throttle the speed to 3G, so that you have time to launch the snippet before the page's JavaScript touches the head.

Network tab with the speed throttled to 3G. In the screenshot "Disable cache" is also ticked.
Go back to Sources > Snippets, reload the page and click "Run" as soon as you can:

Right-click on the snippet and "Run", as soon as you can.
Then set the network back to its normal speed and read the console:

Detector output in a clean case: the meta robots is added to the DOM already as INDEX, FOLLOW.
The screenshot is of a clean case, with an earlier version of the script that only watched the meta robots: the meta didn't exist at the start, it's added directly as INDEX, FOLLOW and doesn't change afterwards. A flash would show up as a "META robots cambiado" line, the previous value, the new one and the trace with the guilty script.
The script has limitations:
- It only watches the first meta robots and the first canonical it finds.
- If the framework removes the tag and inserts it again, adds a second meta robots, uses
meta name="googlebot"or puts it outside the head, it doesn't log it. - Any change before the snippet runs is lost. Hence the 3G and the hurry.
If you know how to program it better and cover those cases, go ahead.
Noindex pages in CSR: links, facets and when robots.txt is worth it
If a paginated series carries noindex on a CSR website, do the links its JavaScript generates exist for Google? I used to say no. Today I'd say "don't count on them". Googlebot running JavaScript on a noindex page doesn't mean it discovers or follows the links that JavaScript generates: in the test above, the JavaScript redirect on the noindex page wasn't followed, although perhaps Google simply didn't want to try it. And what we already knew still holds: a noindex page, in the long run, ends up being treated as nofollow. John Mueller said so in a hangout on 15 December 2017 and it isn't in the documentation.

Google's documentation on pagination talks about recognising and indexing the pages in a sequence.
The documentation doesn't help you decide either: on one hand it explains how it recognises and indexes paginated pages; on the other it recommends not indexing sort variations. That debate is still open.
And one practical consequence: noindex doesn't guarantee you save on rendering or API calls. On a large site, internal search pages and faceted navigation with noindex can keep firing heavy requests at your endpoints. That's where robots.txt can be worth it, because if it blocks the URL, Googlebot doesn't even request it and renders nothing.
But they aren't interchangeable. If Googlebot doesn't request the URL, it doesn't read the noindex it carries either, and blocking isn't deindexing: when I checked it, amstel.es ranked first for its brand while blocked by robots.txt. Noindex when you want the page out of the index; robots.txt when what you want is for Google not to spend resources on it.
The canonical, in the initial HTML
On the important part Google and I agree: the canonical has to be correct already in the initial HTML, and correct means self-referencing (self-canonical) or absent. The documentation says the best way to set it is in the HTML; if you can't, it allows you to add it with JavaScript leaving it out of the initial HTML. What it asks is not to use JavaScript to change it to a different one from the one that came in and, if you inject it, for it to be the only one on the page.
Where we don't agree is on the consequence. My experience is that, if the initial HTML carries a canonical to another URL, Google considers the page non-indexable and doesn't send it to be rendered, even if the JavaScript corrects it afterwards. The typical failure is a canonical to the home page in the static part that the framework then changes in the DOM: at first only the home page would be indexable.
Google doesn't document it that way. As reasons to skip rendering it only mentions noindex and codes other than 200, and about conflicting canonicals it only says they can lead to unexpected results. Mine is consulting experience, with no published experiment; Google's, that the result isn't guaranteed. The advice is the same with both versions: don't rely on fixing the canonical with JavaScript. To catch a framework that changes it, the flash snippet also watches the canonical and tells you which script touches it.
Status codes and soft 404
Whatever doesn't return a 200 may be left unrendered. Google says so conditionally and the measurements point the same way: 304s were rendered with the content of the original 200, but the rest of the 3xx, 4xx and 5xx codes weren't, and in the noindex test the page with a 404 didn't even run the fetch. Content that only appears through JavaScript on a URL that returns 404 doesn't exist for Google.
In an SPA (single-page application) with client-side routing the opposite happens: the server returns 200 for everything and the error is drawn by JavaScript. That's a textbook soft 404. Google offers two ways out, and you can use one or both:
// Option 1: send the user to a URL the server answers with a real 404
if (!producto) {
window.location.href = '/no-encontrado/';
}
// Option 2: mark the error page with a noindex
if (!producto) {
const meta = document.createElement('meta');
meta.name = 'robots';
meta.content = 'noindex';
document.head.appendChild(meta);
}The second is the earlier rule applied on purpose: adding a noindex with JavaScript works.
A piece of advice that's mine, not Google's: avoid the word "404" in the title and the h1, even if you're talking about 404s. The page may be automatically detected as a soft 404, and that check can already be done with the initial HTML, before rendering. Google doesn't document that trigger.
A clean head
Only tags valid for the head fit in the <head>. If you put in one that isn't, any browser, including Google's Chromium, closes the head at that point, and whatever comes after ends up in the body:
<head>
<title>Zapatillas de running</title>
<div id="banner-cookies"></div> <!-- the head closes here -->
<meta name="robots" content="noindex"> <!-- this is already in the body -->
<link rel="canonical" href="https://ejemplo.com/running/">
</head>If the meta robots, the canonical or the hreflang came after it, you've left your most important signals in the wrong place. The usual suspect is a third-party script that injects a div or an iframe into the head.
How to audit it in a minute
Everything in this chapter is checked by requesting the URL without running JavaScript. With curl, from the terminal:
# Status code
curl -s -o /dev/null -w "%{http_code}\n" https://ejemplo.com/pagina/
# X-Robots-Tag header (with GET: a HEAD may respond with different headers)
curl -s -D - -o /dev/null https://ejemplo.com/pagina/ | grep -i x-robots-tag
# Meta robots and canonical in the initial HTML (only the tags, even if the HTML comes on a single line)
curl -s https://ejemplo.com/pagina/ | grep -ioE '<(meta|link)[^>]*(robots|googlebot|canonical)[^>]*>'Then compare the output with the crawled page's HTML in Search Console's URL Inspection. If the server says one thing and the crawled HTML another, you already know where to look.
The 5-second mystery: how long it takes and how long Google waits
"Google renders in 5 seconds." You'll have read it a thousand times, and I wrote it myself: in the advanced guide to rendering I went as far as writing, in capitals, that anything that took more than 5 seconds to appear through JavaScript was invisible to Google. The experiment behind it still gives the same result. What I've had to revise is what that 5 means.
The confusion comes from the sentence mixing up two different questions:
- How long does Google take to render your page after crawling it? It's the wait in the render queue. This is where the first "5 seconds" comes from: a median.
- How long does it let your page run before taking the snapshot? It's what happens inside Google's browser. This is where the second "5 seconds" comes from, the one from the counters, and it's the real mystery.
And there's a third clock that sneaks into both: the time to index, from when you publish until the page appears in the results. That includes URL discovery, the crawl queue, canonicalisation and content quality, as well as the render. From the outside we only see two moments, the request in your logs and the appearance in Google, and we infer what happens in between.
First question: how long Google takes to render
Between Google crawling a page and rendering it, in the vast majority of cases, seconds or minutes go by. These are the published figures:
| Source | What it measures | Figure |
|---|---|---|
| Google, Chrome Dev Summit 2018 (Tom Greenaway and Martin Splitt) | From crawl to render | "Minutes, an hour, days or up to a week". They withdrew it a year later |
| Google, Chrome Dev Summit 2019 | From crawl to having the page rendered | Median of 5 seconds. 90th percentile, "within minutes" |
| Google, SEO on the Beach 2023 | Until the page is rendered | Median of 5 seconds; the slowest 10%, a few minutes |
| Google, 2024 interview | From crawl to render | Minutes for most pages, sometimes hours and very rarely longer |
| Google, Andalu-SEO 2026 | Render queue versus crawl queue, with their logs | 90% of URLs spend only a few minutes in the render queue. The hours or days are lost in the crawl queue |
| Google documentation | Wait in the render queue | A few seconds, although it may take longer. No maximum given |
| Vercel and MERJ (2024) | From the HTML request to the end of the render, on nextjs.org | 25th percentile: 4 s. Median: 10 s. 75th percentile: 26 s. 90th percentile: about 3 h. 99th percentile: about 18 h |
| Tony McCreath (2025) | From serving the HTML to the first request for a render resource | About 23.6 seconds in one case, not an average |
Since 2019 the sources agree on the essentials: almost all pages are rendered within seconds or minutes, and the published medians are between 5 and 10 seconds. That first "5 seconds" is a wait in a queue, and a median at that: half of the pages take longer.
Where the sources stop agreeing is the slowest 10%: minutes according to Google, hours according to the only large external measurement. That measurement has clues as to why. On URLs with parameters the 75th percentile went from 22 seconds to 31 minutes, and sections that change little were rendered later than those that are updated often. Google, for its part, says those long delays exist but aren't down to rendering: the page has been crawled and another system has given it low priority. From the outside it's impossible to separate "it was in the render queue" from "Google decided that URL could wait", and a URL with a ?ref= that doesn't change the content is the perfect candidate to wait. There's no settled figure for that 10%.
The studies most often cited against Google's version, Onely's in 2019 (Tomek Rudzki's own research, published in Search Engine Journal) and in 2022, measure something else. The 2019 one looks at how much JavaScript-dependent content was indexed after a day or a month: that's the third clock, and it doesn't distinguish between "it didn't render it" and "it rendered it and decided not to index it". The 2022 one, the one with the headline "Google needs nine times more time to crawl JavaScript", measures how long Googlebot takes to follow a link that only exists after rendering. Neither of them measures render time, but the second leaves a practical lesson that still stands.
From the "two waves" to the real cost of CSR: discovering links
The idea that JavaScript gets indexed "in a second wave" comes from 2018, when Google explained that it first indexed the HTML and the render came later. In 2020 they acknowledged that the two waves were an oversimplification (Martin Splitt, in the JavaScript SEO office hours of 25 March 2020: "the second wave is an oversimplification"), and today the documentation says that every page with a 200 code goes to the render queue, whether or not it has JavaScript. Even so, the model is still alive in many places, including Screaming Frog's tutorial.
I also wrote in 2023, in my article on the types of rendering, that CSR was "a process that needs 3 crawls". What there is isn't three requests but three phases (crawling the HTML, rendering it and analysing the result again to extract the links), and every page goes through them, not just CSR pages.
The real cost of CSR lies in link discovery. If the links only exist after running JavaScript, each level of depth requires crawling, rendering, analysing again and sending the new URL to the crawl queue. On one level you don't notice it. On seven levels of a newly created site, Onely's experiment took 313 hours to reach the end of the JavaScript chain, versus 36 for the HTML one. More careful measurements give a slight advantage to server-rendered pages, and an up-to-date sitemap greatly reduces that difference or eliminates it.
The practical conclusion: important links go in the initial HTML as <a href> or, at the very least, in the sitemap. Above all on new or rarely crawled projects, which is where the crawl queue weighs most.
"Crawled - currently not indexed" is almost never rendering's fault
If you blame rendering for a delay that is really about crawling or quality, you'll spend weeks of development fixing what isn't broken. The usual suspects for a page that isn't indexed are others. Martin Splitt explained it in the interview with Olga Zarr in May 2024: whether something is indexed depends on whether the content is useful and of quality, and on whether Google already has another one just like it.
- Crawling: the URL takes a while to be discovered or recrawled, which is where the hours and days are lost.
- APIs blocked to bots in applications that draw on the client: Google renders, but the content doesn't arrive.
- Quality: most pages that aren't indexed are in that state because they're weak or because there are already many that answer the same thing.
It's checked in a moment. In Search Console's URL Inspection, look at the crawled page's HTML (the indexed version, not the live test). If your content is there, you don't have a JavaScript problem and it's time to review crawling, linking and content. If it's missing, then you do.
Second question: how long Google waits inside your page
Here's the mystery. To measure it I put a made-up meta tag in the <head>, snapshot-counter, which a setInterval increments every second (the code is further down, in the three meta tag method). When Google crawls the page, I inspect the URL in Search Console without clicking "Test live URL" and look at the meta tag's value in the crawled page's HTML:

Crawled page (the indexed version, not the live test):
snapshot-counter is 5. Also notice the time the JavaScript has written, which ends in :05. I talk about that in how to measure it.It reads 5. I've repeated it on several projects and it always comes out as 5, in the indexed version and in the live test. And the same happens with timers: text the JavaScript draws at 4 seconds appears in the crawled page's HTML; text it draws after 5 doesn't. I published the counter in Calculate Google's rendering time.
It isn't down to my setup. Two other tests give the same result: a title that changes every second stopped at 5, and on a page that logged performance.now() every 10 milliseconds the last value was about 5250, while a 6-second setTimeout never got to run.
So far, everything fits with "Google cuts off at 5 seconds". The problem is what happens with the network. The first of those pages, as well as the counter, made two chained requests to a PHP file that took between 3 and 6 seconds to respond each time: between 6 and 12 seconds in total. With a cut-off at 5 seconds that text couldn't appear, and it did, in the live test and in real indexing. The page itself calculated how long those calls had taken, and inside Googlebot the result was 0.02 seconds.
The explanation is that Google's browser doesn't use the real clock, but one of its own that can speed up, slow down or stop. From what has been measured from inside the page:
- While there are pending network requests, the clock stops. Fifteen resources with a half-second delay each cost almost 10 real seconds and only 162 milliseconds of Google's clock.
- With the CPU busy, the clock barely moves.
- When the page has nothing to do, the clock speeds up: a 5-second timer was fulfilled in about 455 real milliseconds.
- When that clock goes past about 5 seconds, Google stops everything and keeps the DOM. That's why the 6-second timer never arrives.
Google hasn't documented it, but the little it has said fits. Verbally, in a livestream and in an interview, it has said that timers run faster when the page is idle, that the end of rendering isn't marked by a fixed time but that they wait for the browser's event queue to be empty, and that the 5 seconds thing isn't true: "we wait longer if needed", as long as they're confident the wait is going to bring content.
The mystery is solved like this: the 5 seconds exist, but they're seconds on Google's clock, not yours. My counter doesn't time anything. It counts the ticks of a clock Google speeds up when the page is still and freezes when it's working, and it reaches 5 before the cut-off.
What makes it into the snapshot and what doesn't
Putting it all together, the practical rule is this (Google hasn't published it; it comes from the tests):
- A timer longer than about 5 seconds doesn't make it in. A
setTimeout, asetIntervalor an animation that waits before drawing: Google's clock reaches its limit before they fire. - A shorter timer does make it in, and Google doesn't even really wait for it: it fast-forwards it.
- What takes long because an API or a server is slow can make it in, even if 9 or 10 seconds pass on your clock. While there's a pending request, Google's clock doesn't run.
- What takes long because the JavaScript is heavy doesn't use up that clock either, because with the CPU busy it barely moves.
- What depends on a click or a scroll never makes it in, however long it takes.
Whatever depends on a timer longer than about 5 seconds, Google won't see. Whatever takes long because of the network, it can see.
I still hope you won't be naughty and use the first one to do some kind of cloaking. And the second doesn't invite you to cut it fine either: the fact that Google waited for a slow API on a test page doesn't guarantee it will do so with yours.
Try it on your site
The way to really understand it is to see it. This test page brings the four cases together: a 4-second timer, a 6-second one, an API that takes 8 real seconds and text that only appears when you click.
<p id="t4">pendiente</p>
<p id="t6">pendiente</p>
<p id="api">pendiente</p>
<p id="clic">pendiente</p>
<button id="boton">Mostrar</button>
<script>
// 1. 4-second timer
setTimeout(() => {
document.getElementById('t4').textContent = 'temporizador-4s';
}, 4000);
// 2. 6-second timer
setTimeout(() => {
document.getElementById('t6').textContent = 'temporizador-6s';
}, 6000);
// 3. Slow API: the server takes 8 seconds to respond
fetch('/prueba-render/lenta.php', { method: 'POST' })
.then((r) => r.text())
.then((texto) => {
document.getElementById('api').textContent = texto;
});
// 4. Only with a click
document.getElementById('boton').addEventListener('click', () => {
document.getElementById('clic').textContent = 'tras-clic';
});
</script>And the slow PHP, in /prueba-render/lenta.php:
<?php
sleep(8); // eight seconds of real clock time
header('Content-Type: text/plain; charset=utf-8');
header('Cache-Control: no-store');
echo 'api-lenta-8s';The request goes via POST on purpose: Google eagerly caches what it requests via GET, and if it served you the stored response there would be no 8-second wait to measure.
Once Google has crawled the page, inspect the URL without clicking "Test live URL", open "View crawled page" and look for the four ids. What to expect, based on what has been measured:
t4: "temporizador-4s".t6: "pendiente" (pending).api: "api-lenta-8s", even though 8 seconds passed on your clock.clic: "pendiente".
If the timers give you something else, let me know, because it would mean something has changed. If it's the API that stays at "pendiente", it may just be that Google didn't wait that time: the fact that it did in other tests doesn't guarantee it will with yours. Set up the test on a separate page and delete it when you're done.
Don't expect miracles with the network either. Google does have a real-time limit, although it doesn't publish it: Martin Splitt said in the Duda webinar of August 2023 that it exists, that it's very long and that they adjust it often. In one test, a page that kept requesting data was cut off at around 30 seconds in real indexing and between 48 and 54 in the live test, with a cut-off its author considers fairly variable; in another, at 52 seconds Google cancelled the pending requests. Real indexing was stricter than the live test, another reason not to take the live test as the final check.
Google's objection to these tests
Google has an objection to this kind of experiment, and it's only fair to mention it. Asked about pages whose content changes every second, they answered that inside rendering 10 seconds can pass instantly, that timers can fire out of order, that the date may be that of the crawl day and that they wouldn't trust these tests, because an odd setup interferes with rules designed for real websites.
They weren't talking about my counter, but it applies to it just the same. In its favour, it's reproducible: it gives the same result on three different setups. Against it, what it returns isn't real time. That's why I use it as a diagnostic tool (did my JavaScript run? which tick did it reach? if it stays at 0, it didn't run) and not as a stopwatch.
So does speed affect rendering?
It does, but not because Google "leaves at 5 seconds". Content that took 9 or 10 real seconds to arrive over the network was rendered in full. Web performance (WPO) matters for other reasons:
- A slow server reduces crawling: if your server struggles to serve bytes, crawlers slow down on their own and your crawl rate drops.
- Very long network waits do get cut off, with the limits above.
- A page that abuses the CPU or the network is more fragile, in Google and in any browser.
- Users don't wait. The WRS's patience is much greater than a person's.
And don't take that 5 over to Screaming Frog. Its AJAX timeout defaults to 5 seconds, but it's real clock time:

Screaming Frog's AJAX timeout: 5 seconds by default, configurable from 1 to 300. The tool's notice says Googlebot is more flexible and goes by network activity.
If your website depends on an API that takes more than 5 seconds, with the default setting the tool may see less content than Google. Raise it when screenshots come out half-loaded.
Web workers: the case where one second really was the limit
In one case, the threshold was much lower. In 2021 Dave Smart tested whether Google indexes content generated by web workers (scripts that run in the background, off the main thread). The simple worker rendered fine; those that made a fetch always failed, even though Googlebot requested the resource; and the one doing a long calculation only worked when it returned the result in under a second. It's an old test on a single page, and Google has acknowledged that web workers can give odd results because very few websites use them. I wouldn't leave anything you want indexed in the hands of a web worker.
How to measure when it crawls you and when it renders you
Google crawls you at one moment and renders you at another, and only the first is recorded somewhere you can check. For crawling you have two witnesses: your logs and the response Search Console stores. Inspect the URL without clicking "Test live URL" and open "View crawled page" > "More info" > "HTTP response": the Date header is the crawl time.

The crawled page's Date header is the crawl time, not the rendering time.
For rendering you have no witness at all. The WRS doesn't request your HTML again: it works with the one already downloaded. At most you'll see requests to your JS and CSS in the logs, and not even that is certain, because it keeps them in cache for up to 30 days.
The three meta tag method
To get a glimpse of rendering I put together a homemade method with three made-up meta tags in the <head>: one the server fills in with the date, another JavaScript rewrites with the date every second and another JavaScript uses as a counter. The meta tags, with the server date in PHP (use whatever server-side language your website has):
<?php
date_default_timezone_set('Europe/Madrid');
$date = date('d/m/Y H:i:s');
?>
<meta name="user-date" content="<?php echo $date; ?>">
<meta name="user-date-js" content="<?php echo $date; ?>">
<meta name="snapshot-counter" content="0">The script that rewrites the date every second:
function updateMetaDate() {
const metaTag = document.querySelector('meta[name="user-date-js"]');
if (metaTag) {
setInterval(() => {
const now = new Date();
const formattedDate = now.toLocaleString('es-ES', {
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
second: '2-digit'
}).replace(',', '');
metaTag.setAttribute('content', formattedDate);
}, 1000);
}
}
document.addEventListener("DOMContentLoaded", updateMetaDate);And the counter:
document.addEventListener('DOMContentLoaded', () => {
const meta = document.querySelector('meta[name="snapshot-counter"]');
let count = parseInt(meta.getAttribute('content')) || 0;
const intervalId = setInterval(() => {
count++;
meta.setAttribute('content', count.toString());
}, 1000);
window.snapshotIntervalId = intervalId;
});Put both dates in the same format, there's enough confusion with time zones as it is. Once Google has crawled the version with the metas, inspect the URL, open "View crawled page" and search for user-da in the HTML:

The three meta tags in the crawled page's HTML, in Search Console.
Each meta tells you something different:
user-dateis written by your server, so it's the real date of the last crawl.snapshot-countertells you whether your JavaScript ran and how many ticks of Google's clock it managed to count. You already know they aren't seconds.user-date-jslooks like the rendering time, and it isn't.
I got the third one wrong. In my first screenshots the JavaScript date was earlier than the crawl date, and I came to think the page had been rendered almost a day later:

First example: server date of 1 November and JavaScript date of 31 October.
The clue was the time: in all my screenshots, the JavaScript date read 17:00:05 or 16:00:05, depending on the time of year. Converted from Pacific time to UTC, they're always 00:00:05 UTC on the crawl day: midnight plus five ticks of the counter. In real indexing, the clock of Google's browser starts at midnight UTC, and other tests have seen the same. The JavaScript date, therefore, doesn't give you the rendering time; at most it gives you an idea of the day.
In the live test, on the other hand, the clock is the real one:

"Test live URL": here the JavaScript date is a real time, in Pacific time.
There the JavaScript date is a real time, but the live test is precisely where you aren't measuring the rendering that gets indexed.
To measure real time, let your server set the time
If there's no reliable clock inside Google's browser, the time has to be set by someone outside: your server. There are two ways:
- Have the page request a resource whose server returns its real time, and write that time down inside the HTML itself to read it later in URL Inspection.
- Have the page request a text from a server that deliberately takes a few seconds to respond, as in the test above. If the text appears in the rendered HTML, Google waited at least that real time, whatever the counter says.
To write things down inside the HTML without sending anything to your server, a log inside the page itself does the job:
<script type="text/plain" id="html-log"></script>
<script>
const registro = document.getElementById('html-log');
function htmlLog(mensaje) {
registro.appendChild(document.createTextNode(mensaje + '\n'));
}
htmlLog('User Agent: ' + navigator.userAgent);
addEventListener('load', () => htmlLog('Evento: load'));
addEventListener('error', (e) => htmlLog('Error: ' + e.message));
</script>The messages stay inside the rendered HTML and you read them in URL Inspection or in the Rich Results Test. For JavaScript errors, Google suggests another route: a listener for the error event on window that sends the message, the file and the line to a logging service, so you find out what fails for your users and also for Googlebot.
Two traps. The first, the cache: Google caches resources eagerly, and in these tests you'll end up seeing old responses from your server. The second, that you can't generate a unique identifier in the browser, because inside Google Math.random() always returns the same thing and the time is fixed. The ways out are to request via POST or have your server print a different identifier in the HTML on each load. And do it on a test page, not across the whole website: each new resource URL spends crawl budget.
Finally, always check where you read each result. In the live test you'll learn how the tool behaves; on the crawled page, how the real Googlebot behaves. You have to test both, and the one that counts is the second.
Rendering strategies: CSR, SSR, static, ISR, hydration and dynamic rendering
When you work with a JavaScript framework you have to decide where your website is rendered: in the user's browser, on the server on every request, or in advance, at deploy time. It's the idea of template and data from the first chapter: each strategy puts the two together in a different place and at a different moment. With Google you can rank with any of them. What changes is the cost and who pays it: the server, the user or crawling.

How a page travels from the server to the browser. The rendering strategy decides at what point in the journey the HTML is assembled.
The comparison table: CSR, SSR, SSG, DSG and ISR
The five methods and, at the end, two rows that aren't pure methods, but are worth having in view:
| Type | Description | SEO advantages | Considerations |
|---|---|---|---|
| CSR (Client-Side Rendering) | The browser downloads the JavaScript and builds the page. | None of its own. With Google it can rank if it's well developed. | Content and links only exist after the render. It's the most fragile, the JS grows with the application (worse INP, the response to interactions) and crawlers that don't run JS see nothing. |
| SSR (Server-Side Rendering) | The server generates the HTML on every request. | Content, links and meta tags in the initial HTML. | It loads the server and can worsen TTFB (how long the first byte takes to arrive). It needs caching or a good CDN. |
| SSG (Static Site Generation) | The HTML is generated at deploy time and reused on every request. | Fast, stable TTFB. Everything is in the initial HTML. | Any change means redoing practically the whole deploy. It's no good if you can't predict the URLs. |
| DSG (Deferred Static Generation) | Like SSG, but it defers certain pages until someone requests them and then caches them. | Those of SSG on the pages already generated. | Mainly a Gatsby concept. Less customisable than ISR. |
| ISR (Incremental Static Regeneration) | Static that is regenerated page by page, without rebuilding the whole site. | Those of SSG without its big drawback. | The first visit to a page not yet generated resembles SSR. My choice if I can pick on a large project. |
| Hybrid | What matters for SEO comes from the server or is static; the dynamic parts are rendered on the client. | Fast discovery of content and links, with interactivity where needed. | Complex to implement and maintain. |
| Dynamic rendering | CSR for users and a prerendered version for certain user-agents. | None as far as Google is concerned. | Discouraged. Google treats it as a patch and doesn't recommend it. |
For performance, the reference is Rendering on the Web, from web.dev. It compares architectures with four metrics: TTFB, FCP (when the content is seen), INP and TBT (how long the main thread was blocked during loading). For crawling, the most cited table is Vercel and MERJ's, which rates SSG and ISR as excellent, SSR as very good and CSR as poor. That table is its authors' opinion: in their own sample every indexable page ended up rendered.
CSR: it can rank on Google, but knowing what it costs
In CSR the whole front end, including the HTML tags, comes from JavaScript. The advantage is for the server, which suffers far less because the work is done by each user on their device.

Client-Side Rendering: the work of assembling the page is done by the browser.
The problem shows quickly with any pure CSR website: neither in the source code nor in a standard Screaming Frog crawl do internal links, meta tags or content appear. They only show up if you enable JavaScript rendering, and then the crawl takes much longer.

Without this option, Screaming Frog crawls the initial HTML and a CSR website looks empty to it.
CSR isn't penalised: when asked about it, Google answered that, if the page is well developed, there shouldn't be any problem ranking it. Even so, its documentation still says that server-side rendering or prerendering is a great idea, because it makes the website faster and because not all bots run JavaScript. What CSR costs is four things:
- Link discovery. If links only exist after running JS, each level of depth requires crawling, rendering and queuing again (I covered it in the two waves).
- Fragility. A resource blocked in robots.txt, an API that doesn't respond to bots or a JS error, and the page is left empty.
- Crawl budget on large sites. Vercel and MERJ put the threshold at about 10,000 unique pages that change often. Google's documentation only asks you to watch crawl budget from a million URLs that change every week or 10,000 that change daily, and doesn't link it to rendering. What it is and how it's measured, in crawl budget.
- Crawlers that don't run JavaScript. Bing and AI have their own chapter.
All of that demands extra effort, and the initial HTML of each page must be indexable before the JS touches anything.
SSR and static rendering: the content, in the HTML from the first byte
In SSR the JavaScript runs on the server on every request. When the response arrives, the content, the links and the meta tags are already there, for Google and for any bot that only reads HTML.

Server-Side Rendering: the HTML arrives assembled from the server.
It's the most common solution when working with a JS framework, because it solves indexing problems in one fell swoop, and it usually gives a fast FCP because you send less JavaScript. It isn't miraculous: generating the page on the server takes time and can worsen TTFB, and often the same application is processed twice, on the server and on the client. On websites with lots of traffic you need a powerful server, HTML caching or a good CDN.
Static rendering does the same, but only once: it generates the HTML at deploy time and reuses it on every request. That's why its TTFB is fast and stable.

Static rendering: the HTML is generated once and served as is.
Of its three flavours (SSG, DSG and ISR, the ones in the table), the one that makes it scalable is ISR, because it regenerates individual pages without rebuilding the whole site. In Next.js, for example, it's a few lines: the page is served static and regenerated in the background at most once an hour.
// app/productos/[slug]/page.js
export const revalidate = 3600; // seconds
// No pages at build time: each one is generated on its first visit and stays cached
export async function generateStaticParams() {
return [];
}
export default async function Producto({ params }) {
const { slug } = await params; // since Next.js 15, params is a promise
const producto = await obtenerProducto(slug);
return <h1>{producto.nombre}</h1>;
}Static doesn't mean without JavaScript. You can still call APIs and add sections in CSR. To find out what you have there's a very simple test: disable JavaScript and load the page. If almost everything still works, it's truly static.
Hybrid, hydration and islands aren't synonyms
These words are used as if they were the same thing (I've done it too, calling the hybrid "rehydration"), and mixing them up makes it impossible to understand the criticism each one gets:
- Hydration. The HTML arrives complete from the server and the client's JavaScript adds state and interactivity to it.
- Rehydration. It's often used as a synonym, but strictly speaking it implies continuing to update the DOM with the latest state after the initial hydration.
- Progressive or partial rehydration. The pieces are activated over time, or only the interactive ones are activated. Partial rehydration has proven hard to implement.
- Islands. Server HTML with independent widgets that each hydrate on their own (Islands Architecture).
- Hybrid. It's the umbrella term: what matters for SEO comes from the server and the dynamic parts are left to the client, by pieces or by routes.

Hybrid rendering: search engines and people see the same version, but not everything is assembled in the same place.
Hydration is safe for indexing: the content already comes in the initial HTML, and Google suggests it along with SSR and static rendering as an alternative to dynamic rendering. Having the content and links repeated in the HTML and in the hydration data has no side effects either: Google discovers the links twice and that's it.
The criticism it gets is about engineering. The server sends the interface, the data it was composed with and a full copy of the application that boots up again on the client: one application for the price of two. The page looks ready and doesn't respond until the JS runs, and that's paid for in TBT and INP. That's why web.dev recommends SSR or static rendering over a full rehydration.
My rule (whatever affects SEO goes in the server HTML) is met just the same with full hydration, with islands or with a hybrid by routes. What changes is how much you pay in interactivity.
Streaming: what a crawler receives when the HTML arrives in chunks
With streaming the server doesn't wait until it has the whole page. It first sends the shell (layout, navigation and the loading placeholders) and then each block as it resolves, all within the same HTTP response.
In Next.js and React, content that arrives late comes in the HTML inside a hidden div, and a script places it in its slot. A client without JavaScript receives the text, but hidden and out of place. With Google it shouldn't be a problem: content served via streaming has been seen rendered in full.
For everyone else, Next.js distinguishes by user-agent. With the bots it calls "HTML-limited" it waits until the metadata is resolved, so that it goes in the head. Its default list includes Bingbot, Twitterbot, Slackbot and some Google crawlers such as AdsBot-Google, and it can be changed with the htmlLimitedBots option. To the rest, Googlebot included, it may serve the metadata via streaming, added to the body once resolved; Next.js says it has verified that bots that run JavaScript interpret it correctly. I'd still check it in URL Inspection.
React also documents a pattern for crawlers: send the complete HTML at once (onAllReady) instead of the progressive stream (onShellReady) when you detect a bot. That's a different response per user-agent, and it looks a lot like dynamic rendering, with the difference that the content is the same and only the way it's delivered changes. The cost: the crawler has to wait for all the data, and some of it may be slow or fail.
Streaming and status codes: when the 200 has already gone out
Streaming brings a new problem: as soon as the server starts sending, the headers and the status code have already gone out. And they've gone out as 200.
Next.js explains it: if notFound() fires mid-stream, it can no longer return a 404, so it injects a <meta name="robots" content="noindex"> into the HTML so that search engines don't index the page. And a redirect() mid-stream becomes a client-side redirect. To get a real 404 you have to call notFound() before any await or Suspense boundary, for example with a quick check that the slug exists. React acknowledges the same trade-off: an error outside the page's initial shell can end up served with a 200.
In practice, what Next.js does is Google's second way out for soft 404s: a 200 with a noindex that arrives late. It works, but it depends on that noindex being read.
Dynamic rendering: from recommendation to terrible idea
Dynamic rendering consists of detecting crawlers, usually by user-agent, and serving them a prerendered version in static HTML while users receive the CSR version.

Dynamic rendering: two different paths depending on who requests the page.
Its history is that of a recommendation that expired:
- In 2019 Google presented it as an option to consider if your website relied heavily on client-side JavaScript.
- In August 2022 it updated its documentation to say that it's a workaround and not a long-term solution.
- Today it doesn't recommend it, because it adds complexity and resource consumption, and proposes SSR, static rendering or hydration instead. In his Andalu-SEO 2026 slides, Martin Splitt dismisses it with "Terrible idea. Avoid".

The update to Google's documentation of 10 August 2022.
Two clarifications. The first: it isn't cloaking. Google says it generally doesn't consider it cloaking as long as the content is similar. Cloaking is serving a page about cats to users and one about dogs to crawlers. The second: it discourages it because of cost and complexity; its documentation never talks about a penalty.
If you see dynamic rendering recommended in an audit or a presentation, it probably comes from the web.dev page, which is also Google's and still carries the 2019 sentence in its SEO paragraph. It's a mismatch between two Google websites, and Search Central is the one that rules.
As a patch for AIs that don't run JavaScript it's still defensible when you can't touch the front end; I weigh it up in the chapter on outside Google.
How to choose, and why I go with ISR
There's no single right strategy for everything: it depends on how much your content changes, the infrastructure and team you have and what the website is for. Think of them as tools: asking whether SSR or CSR is better is like asking whether you need a hammer or a screwdriver. If your website presents information (a blog, a media outlet, a shop), requiring JavaScript is a disadvantage: it can break, it's slower and it uses more battery, and that's where SSR, prerendering or straight static HTML come in. If what you're building is a highly interactive application, such as a video editor or a CAD tool, CSR makes sense.
You also need to know when not to touch anything. Rebuilding an ecommerce site that draws its products with JavaScript is, for all intents and purposes, a migration, and I wouldn't recommend it without solid data showing the problem is caused by the JavaScript.
My recommendation: for a small, stable project, SSG. For content that changes on every request or is personalised, SSR with good caching. And for a large project with lots of updates that wants to be optimised for SEO, ISR: it has the benefits of static without dying in the attempt every time there's a deploy.

Lighthouse for a website served with ISR.
Changing what Google reads without touching the site's code
You don't need to touch a website's code to change what Google ends up reading from it. When the CMS is rigid, or when the developer tells you that "the implementation you're asking for can't be done in this page's code", there are two routes left: the server and JavaScript. They're in that order on purpose, from cleanest to least clean. What you change on the server goes into the initial HTML and is seen by Google, Bing and AI; what you change with JavaScript is only seen by whoever renders.
Server first: output buffering
Output buffering consists of holding back the final HTML that was about to be sent and modifying it before it reaches the user.
PHP keeps the output in memory with ob_start(), you retouch it and then it's sent (I explained it in detail in my article on the PHP buffer). It can also be done on websites with Python, Java or Ruby. The advantage over JavaScript is that the change appears in the initial HTML as if it had always been there. With it you can:
- Modify the final HTML even if the website is built with "spaghetti code" nobody understands (document the changes well, or the next person who comes along won't know where they come from).
- Change the indexing status of any page.
- Remove, modify or add any tag on a page or a group of pages.
- Remove JS and CSS from the pages where they aren't used, which incidentally improves WPO.
- Modify headings or set up an automatic linking system.
In other words, any change you'd make with JavaScript, except interaction. This example would work on WordPress, Drupal, PrestaShop, Laravel or framework-free PHP, and adds the class buffering-is-working to the home page's h1:
<?php
ob_start(function ($buffer) {
$is_home = ($_SERVER['REQUEST_URI'] == '/' || $_SERVER['REQUEST_URI'] == '/index.php');
if ($is_home) {
$buffer = preg_replace_callback(
'/<h1([^>]*)>/i',
function ($matches) {
$attributes = $matches[1];
if (preg_match('/class=["\']([^"\']*)["\']/', $attributes, $classMatches)) {
$existingClasses = $classMatches[1];
$newClasses = trim($existingClasses . ' buffering-is-working');
$attributes = preg_replace(
'/class=["\'][^"\']*["\']/',
'class="' . $newClasses . '"',
$attributes
);
} else {
$attributes .= ' class="buffering-is-working"';
}
return '<h1' . $attributes . '>';
},
$buffer
);
}
return $buffer;
});
register_shutdown_function(function () {
if (ob_get_length() > 0) {
ob_end_flush();
}
});
?>If when you load the home page you see that class in the source code (Ctrl+U, not the element inspector), the buffer works. From there you replace the regular expression with whatever modification you need.
Enough of the shoddy trick of hiding what's left over with the classic display:none: with the buffer, it simply doesn't come out in the HTML. If you combine the buffer with good caching, it even works on websites built with visual builders such as Elementor or Divi. In WordPress I hook it to the after_setup_theme and shutdown hooks from functions.php or from a custom plugin. And test it first in a development environment: you're touching all the HTML that comes out of the server.
JavaScript as a patch language
Since Google indexes the rendered HTML and extracts the links from there, a script can modify the website as you please, whatever it's built with: anchor text, href, rel or target attributes, headings a cookie plugin slips in, the title, the meta description or an entire JSON-LD (I went into it in JS to improve your content). For Google to take it into account, six conditions must be met:
- The URL must be crawlable, and so must your scripts: Google doesn't run JavaScript from files blocked by robots.txt.
- The URL must be indexable in the initial HTML. A noindex at source can't be fixed with JS.
- The canonical must be correct at source: self-canonical or none.
- There must be some way to insert the script (it's usually easier than it seems).
- The script must run after the element you want to change exists. A defer also works.
- The change mustn't depend on long timers or on interaction.
I used to phrase the last one as "the website must be fast enough". With what we know about Google's clock, your patch isn't left out because the server is slow. It's left out if you hide it behind a long timer or a click.
Examples: links, attributes and OneTrust's headings
You can modify practically any element; all you need to know is how to select it. Let's imagine this link:
<a href="https://example.com" class="example-link" target="_blank" rel="nofollow">Haz clic aquí</a>With JavaScript we could do different things:
// Select the link with the class "example-link"
const link = document.querySelector('.example-link');
// Modify the anchor text
link.innerHTML = 'Este es el nuevo Anchor Text';
// Change the link's URL
link.href = 'https://nuevo-enlace.com';
// Remove the target="_blank"
link.removeAttribute('target');
// Change the nofollow to noopener
if (link.rel === 'nofollow') {
link.rel = 'noopener';
}
// Wrap the link in another tag (last: outerHTML replaces the node
// and the link variable no longer points to the element left in the DOM)
link.outerHTML = `<div class="container">${link.outerHTML}</div>`;A real example: the OneTrust cookie banner injects headings that have no business in the page's hierarchy. This script turns them into divs while keeping attributes and content, in a much simpler way than from the platform itself:
// Select the container element by ID
const container = document.getElementById('onetrust-pc-sdk');
if (container) {
// Select all the headings inside the container
const headings = container.querySelectorAll('h1, h2, h3, h4');
headings.forEach(heading => {
// Create a new div element
const div = document.createElement('div');
// Copy all the heading's attributes to the div
Array.from(heading.attributes).forEach(attr => {
div.setAttribute(attr.name, attr.value);
});
// Copy the heading's content to the div
div.innerHTML = heading.innerHTML;
// Replace the heading with the div in the DOM
heading.replaceWith(div);
});
}Make sure your script loads after OneTrust's. If it runs before, the container doesn't exist yet and there's nothing to change.
Where to put the scripts: your website, Tag Manager or Patches
On your own website all you need is somewhere in the back end from which to load an external JavaScript file or add the script tags to the HTML; if you don't know how, I explain it in how to modify a website without knowing how to program. If you don't have access, you can do it from Google Tag Manager, which after all is a script that lets you insert other scripts:

A custom script inside a Google Tag Manager tag.
That's why structured data or even a noindex can be implemented from Tag Manager: Google sees the rendered DOM. Google itself covers the structured data part in its guide to generating structured data with JavaScript, with Tag Manager as one of the options.
The third option is Ahrefs Patches, which uses the same principle without needing to know JavaScript. It's in Site Audit and it's paid.

Patches, within Ahrefs Site Audit.
The limits of the patch
- Flicker. The change happens when the JS runs, so sometimes the user gets to see the original content before the modified one. It's the price of not touching the server.
- Bing and AI. What's done with JS won't be seen by Bing or by most AI chats, as I explain in their chapter.
- What can't be fixed with JS. The canonical is fixed at source (that's what the buffer is for) and a noindex in the initial HTML can't be removed with JS, as you saw in the initial HTML chapter. JSON-LD, the title and the meta description can be added or changed with JavaScript.
- Changes mid-load. The same mechanism that makes a noindex injected by Tag Manager work can make a meta robots or a canonical that changes value during loading dangerous. If you patch with JS or work with a framework, run the noindex flash snippet.
How do you check that Google has seen the change?
Don't trust your browser's inspector: you do run all the scripts, and in time. For Google, Search Console's URL Inspection (the crawled page, not the live test). If you don't have access, the Rich Results Test, always with the URL and not pasting the code. To see the final HTML of any URL, Ahrefs Page Inspect also works, even though it isn't made for that:

A page's final HTML seen in Ahrefs Page Inspect.
For Bing and AI the check is shorter: Ctrl+U. If the change isn't in the source code, consider it unseen.
How to check what Google has rendered
Not all tools answer the same question. Some tell you what Google has of your page, others what it would see if it came by right now, and others only what a Chrome that resembles it sees. The further the tool is from the real Googlebot, the more useful it is for debugging and the less for stating anything.
| Tool | What it answers | What it doesn't answer |
|---|---|---|
| URL Inspection, indexed version ("View crawled page") | What HTML, headers, console and resources Google has from the last crawl | What it looks like (there's no screenshot) or whether the change you uploaded today works |
| URL Inspection, live test ("Test live URL") | How Google would render the URL right now, with a screenshot | What is indexed, which canonical Google will choose, whether it's a duplicate |
| Rich Results Test | The same as the live test, on other people's websites and on desktop too | Nothing about the index |
| Server logs and crawl stats | Which URLs and resources Google actually requests | What it did with them when rendering |
| Dentsu's Fetch & Render | The screenshot of the whole page | It isn't Google: no guarantee the result is the real one |
| Screaming Frog, Ahrefs Page Inspect | Differences between initial and rendered HTML, on many URLs at once | They aren't Googlebot: different IP, different Chrome, different timings |
| Your browser | What depends on JavaScript and what changes in the DOM | What Googlebot captured |
URL Inspection: indexed version versus live test
URL Inspection and "Test live URL" are two different tools within the same screen, and confusing them is a very common mistake when auditing rendering.
When you inspect a URL without touching anything else, what you see is the last indexed version, not the one currently on the website. In "View crawled page" you have the HTML, the HTTP headers, the JavaScript console output and the loaded resources. That HTML already has your JavaScript's changes applied (that's where I read the meta tags from my tests) and it's what Google actually has. That said, without a screenshot.
"Test live URL" is a live test: Google requests the URL at that moment, examines it, adds the screenshot and shows you how it would look if it came by now. It doesn't predict whether that version will be the canonical, it doesn't detect duplicates and it will never tell you "Crawled - currently not indexed". The canonical Google chooses is only in the indexed data.
Both use the same browser, but not under the same conditions:
| Condition | Live test | Real Googlebot (indexing) |
|---|---|---|
| Resource cache | Requests fresh resources | Uses its cache: JS and CSS up to 30 days old |
| Clock | Real time | Starts at midnight UTC |
| Agent | Google-InspectionTool (Mozilla/5.0 (compatible; Google-InspectionTool/1.0) on desktop), with screenshot | Googlebot, without screenshot |
| IP | According to the documentation, the ranges in common-crawlers.json, the same as Googlebot | The ranges in common-crawlers.json |
| Maximum wait on a page that keeps requesting data | Between 48 and 54 seconds in one published test | About 30 seconds in that same test, with highly variable figures |
The practical rule: live test to debug; crawled page HTML to know what is indexed.
What the screenshot is (and what it isn't)
The screenshot only exists in the live test and only if the test succeeds. It's generated by Google-InspectionTool, not Googlebot. A screenshot is never proof of what Google indexed. It's useful for spotting errors you wouldn't see with the DOM alone, such as a giant hero, and nothing more.
If it doesn't look like what you expected, check the resources first: they may be blocked for Google-InspectionTool, which isn't Googlebot, on your server, your CDN or your firewall. And if what you see is a huge block covering everything, go to 100vh.
The screenshot cuts off at 1750 px (and the desktop one at 10,000)
The screenshot also has a height limit, and Google doesn't document it. The idea of measuring it was Mario Mangas's: we set up pages with cut marks every so many pixels and tested them on two different websites, with different devices and request types (the full experiment is in Where Search Console's rendering cuts off).

One of the pages with pixel marks, in the Search Console rendering viewer.

The second test: the screenshot ends at the same point.
The result was the same in every case: the screenshot is cut off at 1750 px of height. What's below doesn't appear in the image, but it's still in the rendered HTML. It's a limit of the tool. The risk is human: whoever audits by looking at the screenshot may overlook an important element because it doesn't fit in those 1750 px.
To see further down, the Rich Results Test, in desktop mode, shows up to 10,000 px:

In the Rich Results Test you can choose to test as desktop.

The desktop screenshot reaches 10,000 px.
It isn't what mobile-first indexing dictates, but it helps you get an idea.
Rich Results Test: the option for other people's websites
When you don't have access to the project's Search Console, the Rich Results Test gives you the rendered HTML, the console, the resources and a screenshot of any public URL. It's the most accurate thing available for other people's websites, and that's how I detected the Pandora 100vh case. But it's still a live test: it doesn't tell you what is indexed.
Dentsu's Fetch & Render: the whole page, with reservations
Dentsu's Fetch & Render tool (formerly Merkle) has no height limit: it shows you the rendering of the whole page.

Dentsu's Fetch & Render: the complete page.
The catch is that it isn't official. It doesn't usually fail, but sometimes you can see differences with Search Console. I only use it to see what's below the cut-off. If they don't match, Search Console wins.
Screaming Frog and other crawlers: a useful simulation, not Googlebot
To audit thousands of URLs you can't go inspecting them one by one. That's where Screaming Frog comes in with JavaScript rendering enabled (Configuration > Spider > Rendering). What I use most, following its tutorial:
- The JavaScript tab and its filters. The ones I look at most: "Noindex Only in Original HTML", "Canonical Only in Rendered HTML", "Canonical Mismatch", "Contains JavaScript Content", "Contains JavaScript Links" and "Pages with Blocked Resources".
- "Show Differences": if you store the original and the rendered HTML, it diffs the two, with a filter to see which visible text only exists after running JavaScript.
- The "Rendered Page" tab, with a screenshot, very useful on staging, where you can't use URL Inspection.
Watch out for the AJAX timeout: its default 5 seconds have nothing to do with Google's (I explain it in the 5-second mystery).
And don't forget it's a simulation: it has its own rendering implementation, it may run a different version of Chrome and it crawls from a different IP, so your server may serve it something else. The same goes for Ahrefs and its Page Inspect. When they don't match Search Console, URL Inspection rules.
In your browser: without JavaScript, source code versus DOM and throttled network
Three checks that don't need any external tool:
- Disable JavaScript and reload. What disappears is what depends on rendering. The page going blank isn't a problem in itself: it just tells you where to look afterwards in the rendered HTML.
- Compare Ctrl+U with the element inspector: the HTML that arrives from the server versus the DOM after the JavaScript.
- Throttle the network from DevTools and see how much JavaScript is downloaded before the page becomes interactive.
Ctrl+U and the inspector only show the beginning and the end; for what happens in between there's the flash snippet.
Logs and crawl stats: which resources Google actually requests
Since the WRS downloads resources through Googlebot, the JavaScript, CSS and API requests rendering needs end up in your logs. For Google, it's the best source to find out which resources it crawls; the second, the Search Console crawl stats report, which breaks down each resource type by crawler.
In an Apache or Nginx log, this pulls out what Googlebot has requested for rendering:
# Googlebot requests for JS, CSS and APIs, with their response code
grep "Googlebot" access.log | grep -E '\.js|\.css|/api/' | awk '{print $9, $7}' | sort | uniq -c | sort -rnAnyone can call themselves Googlebot in the user-agent, so check the IP. A real Googlebot resolves to a Google domain, and that domain resolves back to the same IP:
host 66.249.66.1
# 1.66.249.66.in-addr.arpa domain name pointer crawl-66-249-66-1.googlebot.com.
host crawl-66-249-66-1.googlebot.com
# crawl-66-249-66-1.googlebot.com has address 66.249.66.1There you can see whether a critical resource returns an error, whether it's blocked or whether Google is spending crawling on files that change URL on every deploy. Two warnings to read them properly: logs tell you what was requested, not what was rendered or when; and a resource not appearing doesn't mean it wasn't used, because it may come from the cache. Requests from Google-InspectionTool, by the way, are your own tests.
Outside Google: Bing, AI chats, their crawlers and AI browsers
Google running your JavaScript doesn't mean anyone else does, and the answer changes depending on who visits the page.
This changes fast, so everything here is dated. If you read it a few months later, repeat the test before trusting it (and that includes trusting me).
Bing: it says it renders, but my tests say otherwise
With Bingbot I've used the same JavaScript counter as with Google. If the crawler runs the script, the counter appears modified in the DOM it stores. To my surprise (not really), the JavaScript changes didn't show up in what Bing had stored, and I got the same on other projects.

The JS counter as Bing Webmaster Tools returned it on 27 November 2025: both dates are identical and the counter is at 0. The script didn't run.
The second clue is in the reports. On sites built in CSR, Bing Webmaster Tools tells you that the canonical, the meta description and the h1 are missing when they do exist. They're false negatives: they're added by JavaScript and don't appear in what Bing has stored. In the same tool's live test, however, they do appear:

Home page of a CSR site: top, what Bing has in its system; bottom, the live test.
Bing, therefore, is capable of rendering when you ask it to live. What I don't see is it doing so in what it uses to index. My opinion is that Bing doesn't render JavaScript, or at least not as thoroughly as Google, and I've also seen it on huge projects with good metrics on Bing. The test is from November 2025 and I still need to repeat it, because Bing has changed its guidelines since then.
Until early 2026, those guidelines recommended dynamic rendering for Bingbot, especially on large sites (suspicious: if they really render, why a prerendered fallback?). In February 2026 Bing rewrote the page to talk about Copilot and grounding, the sources an AI answer relies on, and that paragraph disappeared. According to the version I read at the time (this URL, which when I finished this guide, in October 2026, returned an error page), Bing asks you to let Bingbot crawl and render efficiently, not to hide critical content behind client-side rendering and not to force it to make extra requests. And it warns: what can't be rendered reliably may not be indexed or chosen for AI answers.
It isn't a ban on dynamic rendering: Bing accepted it if the content is the same for everyone, and other Microsoft documentation still recommends it. The way I read it: Bing still says it renders, but it now asks you not to make the important stuff depend on the client. An amusing detail: that guidelines page is built in CSR, and without JavaScript it returns an empty container.
Four ways an AI visits your website
When someone asks whether ChatGPT or Claude "render JavaScript", the answer depends on which part of the product is visiting the page:
| Who visits | What it does | Does it run JavaScript? |
|---|---|---|
| The chat, when you give it a URL | Requests the page at that moment to answer you | Almost never: it reads the HTML the server returns |
| Background crawlers (GPTBot, ClaudeBot, PerplexityBot…) | Go through the web to train models or feed their own index | No. They download the JS files but don't run them |
| Google's index (AI Overviews, AI Mode) | Retrieves pages from Google's index | Not at that moment: it uses what Google has already indexed, which is the rendered HTML (this is an inference; Google doesn't say it in those words) |
| An AI browser or agent (the Claude Code browser, Claude in Chrome, Perplexity's Comet, the ChatGPT agent, Google-Agent…) | Opens the page in a real browser and acts on it | Yes: it's a browser, with its JavaScript and its CSS |
The fourth is the one most often forgotten, and it explains why the same product can give you two different answers about the same page. Since March 2026 Google has had a documented fetcher for this, Google-Agent, which agents hosted on Google's infrastructure use to browse the web and take actions at the user's request, with its own IP ranges in user-triggered-agents.json. ChatGPT Atlas, OpenAI's browser, would be in this row if it still existed: OpenAI announced its retirement on 9 July 2026 and it stopped working on 9 August, with the promise of bringing that agentic browsing to ChatGPT.
AI chats: the discount code test
The starting point was an experiment by Andre Alpar (Search Engine World, 9 June 2026, updated 2 July), who published a table with the AI chats that ran JavaScript and those that didn't. His setup was more complete than mine: a decoy value in the HTML, the real value loaded by JavaScript from another endpoint and the logs of the three requests.

Table from Andre Alpar's experiment. The material is his, not mine.
My curious nature won't let me have blind faith, so I replicated it myself. On the Andalu-SEO website I put a discount code whose text is only loaded by JavaScript: it isn't in the server HTML. You give the chat the URL and ask it whether there's any discount for next year. If it answers with the code, it has run the script. If not, it has stuck with the server HTML.
To make it fair I took care of three things:
- I forced a cache change and launched the question in all the chats at the same time, so none had an advantage.
- I measured how long the value takes to appear, to rule out any of them taking its snapshot before the script loaded. From Spain it's about 300 ms.
- Since Andalu-SEO has no CDN, I repeated the measurement with a VPN from Australia, in case some AI server handled it from there.

Measurement from Spain: the value is injected at 300 ms.

The same measurement with the VPN connected in Melbourne.
These are the results as of 25 June 2026, after 5 tests (I keep the table up to date in my article on GEO, SEO for language models):
| Chat | Andre Alpar's analysis | My tests (as of 25 June 2026) |
|---|---|---|
| Qwen | Renders JS | Renders JS |
| DeepSeek | Renders JS | Sometimes |
| Kimi | Renders JS | Sometimes |
| Mistral | Renders JS | Sometimes |
| Grok | Runs JS but ignores the result | Doesn't render |
| ChatGPT | Doesn't render | Doesn't render |
| Claude | Doesn't render | Doesn't render |
| Gemini | Doesn't render | Doesn't render |
| Perplexity | Doesn't render | Doesn't render |
| Copilot | Doesn't render | Doesn't render |
On the big ones we agree: ChatGPT, Claude, Gemini, Perplexity and Copilot didn't see the code, and Qwen did. The differences are in the rest. DeepSeek and Kimi saw it some times and not others, Schrödinger's rendering. Mistral shows up as "sometimes", although in the screenshots I've published it wasn't able to: take it as a "don't count on it". And Perplexity gave me hope by offering to verify it, but no.
The test measures something very specific: what the chat sees when you give it a URL and it has to read it at that moment, the first row of the four-ways table. It doesn't measure the background crawling these companies use to train their models or feed their indexes. Nor have I published the server logs, so I can't prove whether each chat actually requested the URL or answered with what it already had. What I do know is that the method detects rendering when there is any, because Qwen saw the value. It's 5 tests, and I'll keep repeating them.
A chat isn't a browser
The discount test doesn't measure AI browsers and agents either, and there the result is the opposite. A chat that "reads a URL" usually makes an HTTP request, receives the HTML and passes it to the model converted into text: if there's no browser involved, nobody runs the JavaScript. An AI browser opens the page in a real browser, with its JavaScript and its CSS, and what reaches the model is the result.
The difference can be seen within the same product. Claude Code has two ways of opening a website, and on 4 October 2026 the Andalu-SEO page went through both:
- Its URL reading tool, the one that works like a chat, answered that the page doesn't mention any discount for 2027 and listed the hotel codes, which are in the server HTML.
- Its built-in browser, a Chromium, loaded the page, and the block with the discount code was in the DOM.
"Claude doesn't render JavaScript" is true for the chat and stops being true when Claude drives a browser, and the same goes for any product that has both.
For these agents, Google describes three ways of reading a website: looking at screenshots, walking the DOM and interpreting the accessibility tree. There it's no longer enough for the text to be in the DOM: how it's painted and how the HTML describes it also count, which is why it recommends semantic HTML and points to web.dev's guide on agent-ready sites.
It's best not to draw the wrong conclusion from this. An agent with a browser goes where its user sends it. To become the page it's sent to, or the one a chat cites, you still depend on what crawlers and chats read, which is the server HTML. And I've only tested one browser.
AI crawlers: they download the JavaScript, but don't run it
For background crawling, the best public data I know of is Vercel and MERJ's study on AI crawlers, from December 2024, done with the logs of Vercel's network. None of the big ones ran JavaScript: not OpenAI's (GPTBot, OAI-SearchBot, ChatGPT-User), nor ClaudeBot, nor Meta-ExternalAgent, nor Bytespider, nor PerplexityBot, nor Common Crawl's CCBot. The exception was AppleBot, which crawls with a browser.
They do download the JS files: on nextjs.org they made up 11.5% of ChatGPT's requests and 23.8% of Claude's. And they crawl much worse than Google: around 34% of their requests ended in a 404, versus 8% for Googlebot on the same site. It's a snapshot of a single site from almost two years ago. The reason, in my opinion, is economic: crawling with JavaScript is much more expensive, and they get what they want without doing it.
You can see your page as one of these crawlers receives it by requesting it without running JavaScript and with its user-agent (GPTBot's official string, with its version, is in the OpenAI documentation and changes from time to time):
curl -s -A "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.4; +https://openai.com/gptbot" \
https://ejemplo.com/pagina/ | grep -c "una frase de tu contenido principal"If it returns 0, that text doesn't exist for them.
Gemini, AI Overviews and AI Mode: the Google index route
With Google there are two different questions. The first: does the crawling that feeds Gemini render? Google hasn't said so in those words. Vercel and MERJ inferred from their logs, in their December 2024 study, that Gemini "leverages Googlebot's infrastructure" and that this gives it the same rendering as Search. It's their inference, not a statement from Google. The second: does Gemini run the JavaScript when you give it a URL in the chat? In my tests it didn't see the value. It isn't a contradiction: one thing is what Google has already crawled and rendered at its own pace, and another is the live read from the chat, which may be a simple request or pull from an earlier copy. The latter is a hypothesis; without logs I can't prove it.
AI Overviews and AI Mode pull from Google's index. To appear as a link, it's enough for the page to be indexed and eligible to be shown with a snippet, with no additional technical requirements, and Google processes content that depends on JavaScript as long as it isn't blocked. Since 31 August 2026 there's one more condition, and it isn't technical: the property can't be excluded from generative AI features in Search Console. That control comes enabled by default (include), is inherited from the parent property, covers AI Overviews, AI Mode and Discover's generative features, and affects neither ranking nor model training; Google's guide to generative AI features already lists it among the requirements. If Google has already rendered and indexed your CSR, it's reasonable to expect its AI features to see that content just like classic search. For the live read and for the rest of the chats, don't count on it.
What to do: the important content, in the server HTML
The rule follows on its own: whatever you want AI to read has to be in the HTML the server returns. Main content, title, metadata and navigation. It doesn't matter whether it's SSR, static or ISR. If your focus is Google, CSR may do; for ranking in LLMs it isn't a good option, and with Bing you lose opportunities.
And what if you can't touch the architecture? Dynamic rendering only for LLM user-agents remains as a workaround, with two caveats: Google advises against it, and it depends on recognising the user-agent, when not all LLMs identify themselves (Grok presents itself with an iPhone's and Copilot doesn't have one of its own).
About llms.txt: on Google it gets no special treatment. The documentation has said so since 15 June 2026: Search ignores it, it neither helps nor harms, and maintaining it for other services that do use it is up to you. Martin Splitt repeated it at Andalu-SEO 2026, and I had already written that neither llms.txt nor ai.txt work.
To check it, the source code is enough, without running JavaScript. If the data isn't there, today most chats and almost all AI crawlers won't see it.
Checklist to audit your site's rendering
There's no new theory here: it's the whole guide in list form, in the order in which I audit a website. Each point links to the chapter that explains it.
The HTML that comes out of the server
- The URL returns a real 200 if it exists and a real 404 if it doesn't (status codes).
- In an SPA, error pages redirect to a URL that returns 404 from the server or receive a noindex via JS.
- The initial HTML doesn't carry a noindex if you want the page indexed: removing it afterwards with JavaScript doesn't work (noindex at source).
- The canonical comes out of the server correct (to itself, or none), there's only one and no script changes it (the canonical).
- The meta robots and the canonical don't change during loading. If Search Console flags noindex and the live test says index, run the flash snippet.
- The title, meta tags, canonical and essential structured data go at the top and within the first 2 MB of uncompressed HTML, headers included; heavy CSS and JS go to external files (the 2 MB limit).
- The
<head>only contains valid tags.
Content and links
- The main content is in the server HTML. It's the only way for Google, Bing and AI to read it at the same time.
- Nothing important depends on a click, a scroll or accepting a permission (no clicks).
- Nothing important depends on a timer longer than about 5 seconds (the 5-second mystery).
- A slow API isn't the end of the world, but don't cut it fine: the cut-off observed in real indexing is around 30 seconds, and it varies.
- Lazy loading fires on visibility (
loading="lazy"or IntersectionObserver), not on the scroll event (lazy loading). - Links are
<a href>with real URLs, and an SPA's views use the History API instead of#fragments. - Important links are in the initial HTML or, at the very least, in an up-to-date sitemap (discovering links).
CSS and window
- Every block with
100vhordvhhas a reasonablemax-height(I usually set 800 px). It costs one line and saves you the debate (100vh). - There's no relevant text inside
::beforeor::after(pseudo-elements). - If the Search Console screenshot is cut off at 1750 px, don't panic: it's the viewer's limit (the cut-off).
Resources, cache and robots.txt
- robots.txt doesn't block the JS, the CSS or the APIs that draw the content (blocked resources).
- Files carry a content fingerprint in their name, which only changes when the file changes (the cache).
- Critical JS and CSS are served from the same hostname; to another host, only videos or downloads.
- No necessary file exceeds 2 MB uncompressed.
- Nothing depends on cookies,
localStorageorsessionStorage, or on WebSockets, WebRTC or web workers.
How to check it, step by step
- Request the URL without JavaScript (
curlor Ctrl+U) and look at the status code, the meta robots and the canonical. - Open URL Inspection in Search Console and look at the crawled page's HTML. That's what Google actually has. If the content is there, you don't have a JavaScript problem (URL Inspection).
- Use "Test live URL" to debug: resources that don't load, console errors. Not for the final check, because it doesn't use Google's cache.
- If the website isn't yours, use the Rich Results Test.
- Crawl with Screaming Frog with JavaScript rendering enabled and compare the initial HTML with the rendered one. Everything that only exists in the rendered one is what you leave in the hands of the JS.
- Check the logs: which resources Googlebot requests and whether your server responds slowly.
Bing and AI
- In my tests Bing doesn't reflect changes made by JS in its index, and its guidelines ask you not to hide critical content behind client-side rendering.
- Most AI chats read the HTML without running JS. Check the date of the last test before deciding anything based on it.
- An AI browser does run your JavaScript, but it arrives when a user sends it. Don't use it as an excuse to leave content out of the HTML.
- If the content, the title, the canonical or the h1 aren't in the HTML without JavaScript, consider them unseen by Bing and by most AI (what to do).
Which strategy to choose, in two questions
- Does your website live off people finding its content (blog, media outlet, ecommerce, listings)? If it changes little, static. If it changes on every request, SSR. If it's large and changes often, ISR.
- Is it an interactive application (a dashboard, a tool, something behind a login)? CSR, accepting the cost: links that only exist after rendering, more fragility and Bing and AI in the dark. The little of that application you want to rank, in the server HTML (strategies).
Open questions
There are things in this guide that aren't settled:
- That the clock in Google's browser isn't ours and that the counters' 5 are its seconds has been measured in several tests and fits with what Google has said, but it isn't documented.
- Nobody knows how long the slowest 10% of pages in the render queue really wait.
- There's no published experiment proving that a 100vh hero harms indexing. I've seen things improve when it was fixed, but that's experience.
- Nor is it documented that a canonical to another URL cuts off rendering, or whether Google uses the links on a noindex page that it does end up rendering.
And almost all the figures in the guide (the 5 seconds of Google's clock, the 1742 px of the window, the 30 seconds of maximum wait) are observations from tests, not documentation: they may change tomorrow.
I still need to repeat the Bing test with its new guidelines, rerun the AI chat test while keeping the server logs, test more AI browsers and publish a 100vh case with before and after data. As I do, I'll update this guide with the date.
Some of what I explain here corrects what I myself had published: the cut-off at 5 seconds, Googlebot's scrolling, the "3 crawls" of CSR and that LLMs never run JavaScript. If you read something different in an old article on my blog, what it says here is what holds.
The check, in the meantime, is the same as ever: URL Inspection in Search Console, "View crawled page", and compare that HTML with what you think you're serving.
References
- Andalu-SEO (n.d.). Rendering: What, how, why. andalu-seo.es. https://andalu-seo.es/ponente/2026/martin-splitt
- andalu-seo.es (n.d.). Andalu-SEO | Evento de SEO Avanzado. https://andalu-seo.es/ (The test page: the discount code that is only loaded by JavaScript)
- Google Help (n.d.). URL Inspection tool - Search Console Help. https://support.google.com/webmasters/answer/9012289?hl=en
- Bing Webmaster Blog (2018, October 31). bingbot Series: JavaScript, Dynamic Rendering, and Cloaking. Oh My!. https://blogs.bing.com/webmaster/october-2018/bingbot-Series-JavaScript,-Dynamic-Rendering,-and-Cloaking-Oh-My
- bing.com (n.d.). Bing Webmaster Guidelines. https://www.bing.com/webmasters/help/webmaster-guidelines-30fba23a
- Bućko, Z. (2022, November 9). Rendering Queue: Google Needs 9X More Time To Crawl JS Than HTML. onely.com. https://www.onely.com/blog/google-needs-9x-more-time-to-crawl-js-than-html/
- Costello, R. (2019, July 22). How JavaScript Rendering Works. lumar.io. https://www.lumar.io/ebooks/javascript-seo-guide/how-javascript-rendering-works/
- Duda (2023, August 22). Exploring the Art of Rendering with Google's Martin Splitt. youtube.com. https://www.youtube.com/watch?v=-newLrArh6c
- Google Search Central (2019, May 7). The new evergreen Googlebot. https://developers.google.com/search/blog/2019/05/the-new-evergreen-googlebot
- Google Search Central (n.d.). AI features and your website. https://developers.google.com/search/docs/appearance/ai-features
- Google Search Central (n.d.). Dynamic Rendering as a Workaround. https://developers.google.com/search/docs/crawling-indexing/javascript/dynamic-rendering
- Google Search Central (n.d.). Fix Lazy-Loaded Website Content. https://developers.google.com/search/docs/crawling-indexing/javascript/lazy-loading
- Google Search Central (n.d.). Fix Search-related JavaScript problems. https://developers.google.com/search/docs/crawling-indexing/javascript/fix-search-javascript
- Google Search Central (n.d.). Generate Structured Data with JavaScript. https://developers.google.com/search/docs/appearance/structured-data/generate-structured-data-with-javascript
- Google Search Central (n.d.). Google's common crawlers. https://developers.google.com/search/docs/crawling-indexing/google-common-crawlers
- Google Search Central (n.d.). Optimizing your website for generative AI features on Google Search. https://developers.google.com/search/docs/fundamentals/ai-optimization-guide
- Google Search Central (n.d.). Pagination Best Practices for Google. https://developers.google.com/search/docs/specialty/ecommerce/pagination-and-incremental-page-loading
- Google Search Central (n.d.). Understand the JavaScript SEO basics. https://developers.google.com/search/docs/crawling-indexing/javascript/javascript-seo-basics
- Illyes, G. (2026, March 31). Inside Googlebot: demystifying crawling, fetching, and the bytes we process. Google Search Central. https://developers.google.com/search/blog/2026/03/crawler-blog-post
- learn.microsoft.com (n.d.). Use public websites to improve generative answers (Microsoft Copilot Studio). https://learn.microsoft.com/en-us/microsoft-copilot-studio/guidance/generative-ai-public-websites
- Miller, J. (2020, August 11). Islands Architecture. jasonformat.com. https://jasonformat.com/islands-architecture/
- nextjs.org (n.d.). Streaming (Next.js documentation). https://nextjs.org/docs/app/guides/streaming
- nextjs.org (n.d.). generateMetadata (Next.js documentation). https://nextjs.org/docs/app/api-reference/functions/generate-metadata
- nextjs.org (n.d.). htmlLimitedBots (Next.js documentation). https://nextjs.org/docs/app/api-reference/config/next-config-js/htmlLimitedBots
- Osmani, A. and Miller, J. (2019, February 6). Rendering on the Web. web.dev. https://web.dev/articles/rendering-on-the-web
- react.dev (n.d.). renderToPipeableStream (React documentation). https://react.dev/reference/react-dom/server/renderToPipeableStream
- Rudzki, T. (2019, November 22). JavaScript Indexing Delays Are Still an Issue for Google. Search Engine Journal. https://www.searchenginejournal.com/javascript-indexing-delays-google/335703/
- Sánchez, C. (2023, July 10). SEO rendering. sanchezdonate.net. https://sanchezdonate.net/en/article/seo-rendering/
- Sánchez, C. (2023, March 16). JavaScript renderings in SEO. sanchezdonate.net. https://sanchezdonate.net/en/article/javascript-renderings-in-seo/
- Sánchez, C. (2023, June 19). Renderizado en el SEO – Ponencia de Martin Splitt (Spanish). sanchezdonate.net. https://sanchezdonate.net/articulo/noticia/martin-splitt-renderizacion/
- Sánchez, C. (2024, March 17). The hidden SEO risk of using vh units. sanchezdonate.net. https://sanchezdonate.net/en/article/the-hidden-seo-risk-of-using-vh-units/
- Sánchez, C. (2024, January 19). Diferencias entre Java y JavaScript. No son lo mismo (Spanish). sanchezdonate.net. https://sanchezdonate.net/articulo/curiosidades/java-javascript-seo/
- Sánchez, C. (2025, December 1). Advanced SEO Guide to Rendering: How to Debug, Test & Control What Google Sees. sitebulb.com. https://sitebulb.com/resources/guides/advanced-seo-guide-to-rendering-how-to-debug-test-control-what-google-sees/
- Sánchez, C. (2025, November 11). Advanced SEO guide to rendering. sanchezdonate.net. https://sanchezdonate.net/en/article/advanced-seo-guide-to-rendering/
- Sánchez, C. (2025, August 12). AIO or GEO: SEO focused on LLMs. sanchezdonate.net. https://sanchezdonate.net/en/article/aio-or-geo-the-new-seo-for-lmms/#javascript
- Sánchez, C. (2025, June 17). Donde corta el renderizado de Search Console (Spanish). sanchezdonate.net. https://sanchezdonate.net/articulo/curiosidades/donde-corta-el-renderizado-de-search-console/
- Sánchez, C. (2025, January 22). JS to improve your content. sanchezdonate.net. https://sanchezdonate.net/en/article/js-to-improve-your-content/
- Sánchez, C. (2025, November 4). Calculate Google's rendering time. sanchezdonate.net. https://sanchezdonate.net/en/article/calculate-googles-rendering-time/
- Sánchez, C. (2025, March 7). Advanced optimisation with the PHP buffer: modifying the HTML output before sending. sanchezdonate.net. https://sanchezdonate.net/en/article/php-buffer-modifying-html-output-before-sending/
- Sánchez, C. (2025, November 9). Renderizado. Revisar flashazos de noindex (Spanish). sanchezdonate.net. https://sanchezdonate.net/articulo/curiosidades/revisar-flashazos-noindex/
- Schwartz, B. (2017, December 28). Google: Long Term Noindex Will Lead To Nofollow Also. Search Engine Roundtable. https://www.seroundtable.com/google-long-term-noindex-follow-24990.html
- Schwartz, B. (2018, January 18). GoogleBot Can Now Crawl Mobile 12,140 Pixels High & Desktop 9,307 Pixels High. Search Engine Roundtable. https://www.seroundtable.com/googlebot-taller-pixels-25098.html
- Schwartz, B. (2020, March 27). Google Says There Is No Such Thing As Two Waves Of Indexing Or Crawling. Search Engine Roundtable. https://www.seroundtable.com/google-no-two-waves-indexing-29225.html
- Schwartz, B. (2026, February 26). Bing Webmaster Guidelines Updated. Search Engine Roundtable. https://www.seroundtable.com/bing-webmaster-guidelines-updated-41002.html
- Screaming Frog (2017, January 5). How To Crawl JavaScript Websites. https://www.screamingfrog.co.uk/seo-spider/tutorials/crawl-javascript-seo/
- Siddle, R. (2021, July 12). 12 Experiments for Tabbed Content SEO. merj.com. https://merj.com/blog/12-experiments-for-tabbed-content-seo
- Smart, D. (2021, September 11). Web Worker Content - Will It Index?. tamethebots.com. https://tamethebots.com/blog-n-bits/will-web-worker-contents-index
- Smart, D. (2025, June 24). Noindex No Longer Means Not Rendered. tamethebots.com. https://tamethebots.com/blog-n-bits/noindex-does-not-mean-not-rendered
- Smart, D. (2026, July 23). Google doesn't cut off rendering after 5 seconds, but I understand why you might think it does.. tamethebots.com. https://tamethebots.com/blog-n-bits/the-5-second-google-render-limit-myth
- Southern, M. G. (2025, May 2). Server-Side vs. Client-Side Rendering: What Google Recommends. Search Engine Journal. https://www.searchenginejournal.com/server-side-vs-client-side-rendering-what-google-recommends/545946/
- Southern, M. G. (2026, February 27). Bing Adds GEO To Official Guidelines, Expands AI Abuse Definitions. Search Engine Journal. https://www.searchenginejournal.com/bing-adds-geo-to-official-guidelines-expands-ai-abuse-definitions/568442/
- Splitt, M. (2019, November 12). How to make your content shine on Google Search (Chrome Dev Summit 2019). youtube.com. https://www.youtube.com/watch?v=4pOH8Smd0Xs
- Splitt, M. (2023, June 18). What rendering really means for SEO - Martin Splitt #SOB23. youtube.com. https://www.youtube.com/watch?v=BU8ZvTq4A6M
- Splitt, M. (n.d.). Rendering: What, how, why (slides from the Andalu-SEO 2026 talk). andalu-seo.es. https://andalu-seo.es/ponente/2026/pdf/04-rendering-golden-circle-martin-splitt.pdf
- Splitt, M. and Illyes, G. (2024, December 3). Crawling December: The how and why of Googlebot crawling. Google Search Central. https://developers.google.com/search/blog/2024/12/crawling-december-resources
- Splitt, M. and Mueller, J. (2025, July 24). How does CSS affect SEO? (Search Off the Record, episode 96). youtube.com. https://www.youtube.com/watch?v=l2E3gBDP_qY
- Suzuki, K. (2025, May 1). Kenichi Suzuki's interview with Martin Splitt on structured data and JavaScript. youtube.com. https://www.youtube.com/watch?v=jHYUD0x44uM
- Tony (2025, September 5). Tony's Theory of Googlebot Relativity. bigcommerce.websiteadvantage.com.au. https://bigcommerce.websiteadvantage.com.au/tonys-theory-of-googlebot-relativity/
- web.dev (n.d.). Build agent-friendly websites. https://web.dev/articles/ai-agent-site-ux
- Zarr, O. (2024, December 30). JavaScript SEO Guide for SEOs and Developers. seosly.com. https://seosly.com/blog/javascript-seo/
- Zarr, O. (2024, May 6). JavaScript SEO in 2024 Q&A with Martin Splitt from Google (Issues, Mistakes, Tips, Facts, & Myths). youtube.com. https://www.youtube.com/watch?v=0iHDk7uqByI
- Zecchini, G., Moore, A. A., Ubl, M. and Siddle, R. (2024, December 17). The rise of the AI crawler. vercel.com. https://vercel.com/blog/the-rise-of-the-ai-crawler
- Zecchini, G., Moore, A. A., Ubl, M. and Siddle, R. (2024, July 31). How Google handles JavaScript throughout the indexing process. vercel.com. https://vercel.com/blog/how-google-handles-javascript-throughout-the-indexing-process
I currently offer advanced SEO training in Spanish. Would you like me to create an English version? Let me know!
Tell me you're interested


