Crawling

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.

Ultra guide to rendering in Google: what Googlebot runs, when it takes the snapshot and how to check it
Author
Carlos Sánchez
Topics
Crawling Technologies
Published
Reviewed
Index show

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

Six words you're going to read a lot

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 pointWhat is knownStatusWhere it comes from
What Google indexesThe rendered HTML: the DOM that is left after running the JavaScript, not the source codeKnown for certainGoogle documentation
Which pages it rendersThe 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 renderingDisputedGoogle documentation and Search Off the Record (2024) versus the Duda webinar (2023); measurement by Vercel and MERJ
Wait between crawling and renderingSeconds or minutes for the vast majority of pages. The medians given range from 5 seconds (Google, verbally) to 10 (an external measurement)Known for certainGoogle; Vercel and MERJ
The slowest 10% of that waitMinutes according to Google; about 3 hours at the 90th percentile and about 18 at the 99th according to an external measurementDisputedGoogle versus Vercel and MERJ
When it takes the snapshotWhen 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 inWorth reviewingMy tests, Dave Smart's and Tony McCreath's (Website Advantage). Google doesn't document it
Maximum wait in real timeAbout 30 seconds in real indexing and about 50 in the live test. Google doesn't give the figureWorth reviewingTests by Dave Smart and Tony McCreath
JS and CSS cacheUp to 30 days, ignoring your cache headersKnown for certainGoogle (Crawling December)
How much Googlebot downloads2 MB per URL and per resource, measured uncompressed and including the HTTP headers (64 MB for PDFs). Whatever comes after that doesn't existKnown for certainGooglebot documentation (3 February 2026) and Gary Illyes's post (31 March 2026); it warns that it may change
Clicks, scroll and stateIt doesn't click or scroll and doesn't keep cookies or storage between loadsKnown for certainGoogle documentation
How it sees what's further downIt enlarges the window (viewport expansion) instead of scrollingKnown for certainGoogle; measured by Tony McCreath
Window and screenshot dimensions981 × 1742 px at the start on mobile and over a million pixels tall in one test. The Search Console screenshot cuts off at 1750 pxWorth reviewingTony McCreath; my test with Mario Mangas
Hero at 100vh without max-heightIt stretches with the window and distorts the screenshot. That it also harms indexing hasn't been provenDisputedMy experience on projects versus Google
Removing a noindex with JavaScriptIt doesn't work. Adding it with JavaScript doesKnown for certainGoogle; 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 noindexWorth reviewingDocumentation (since December 2025); test by Dave Smart
Canonical to another URL in the initial HTMLGoogle only says that conflicting canonicals, or ones changed by JavaScript, can lead to unexpected results. In my experience, the page doesn't even get renderedDisputedDocumentation versus my experience, with no published experiment
Links that only exist through JavaScriptThey are discovered later, especially on new sites. An up-to-date sitemap greatly reduces the differenceKnown for certainOnely; Vercel and MERJ
Dynamic renderingGoogle advises against it: it's a patch, not a solutionKnown for certainGoogle documentation
Web workersA simple worker was rendered; those that requested data or took longer than a second were notWorth reviewingDave Smart's 2021 test, not repeated
BingIt says it renders. In my tests, its index doesn't reflect changes made by JavaScriptDisputedBing guidelines versus my test
AI chats when you give them a URLMost read only the HTML. Qwen ran the JavaScript; DeepSeek, Kimi and Mistral, sometimesWorth reviewingMy tests (June 2026)
AI crawlersThey download the JS files but don't run them. The exception is AppleBot; Gemini is a separate caseWorth reviewingVercel and MERJ (December 2024)
AI browsers and agentsThey open the page in a real browser, so the JavaScript runs. I've only tested oneKnown for certainGoogle; my test with the Claude Code browser
AI Overviews and AI ModeThey 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 itKnown for certainGoogle documentation; Search Console help (control rolled out on 31 August 2026)

Each row is explained in its own chapter:

  1. What rendering is and why the HTML you write isn't the one that counts
  2. How Google renders: from the crawl queue to the WRS
  3. What Google sees and what it doesn't: clicks, scroll, window, resources and cache
  4. The initial HTML rules: noindex, canonical, status codes and soft 404
  5. The 5-second mystery: how long it takes and how long Google waits
  6. Rendering strategies: CSR, SSR, static, ISR, hydration and dynamic rendering
  7. Changing what Google reads without touching the site's code
  8. How to check what Google has rendered
  9. Outside Google: Bing, AI chats, their crawlers and AI browsers
  10. Checklist to audit your site's rendering
  11. 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).

Diagram with an HTML document on the left and, on the right, the same document turned into a DOM tree with its html, head, body, h1, p and table nodes
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:

  1. Parsing: it reads the HTML and CSS it has received.
  2. DOM and CSSOM: with the HTML it builds the DOM and with the CSS its equivalent for styles, the CSSOM.
  3. Render tree: the combination of DOM and CSSOM, with only what is going to be seen.
  4. Layout: it works out where each thing goes and how big it is on screen.
  5. 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:

Chrome DevTools performance chart between 500 and 1500 milliseconds: a yellow JavaScript stretch followed by a much longer purple layout block and, at the end, green painting spikes
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.

Source code of an Ahrefs blog article opened with view-source in Chrome
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.

Chrome DevTools Elements panel on the same page, with the DOM tree expanded and a reading progress div with an inline width of 13.3312 %
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)

Illustration of a server sending HTML, CSS and JS files to a computer and a mobile phone
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

  1. Discovery. The URL arrives through links, sitemaps or Search Console.
  2. 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.
  3. Crawling. It downloads the HTML and nothing else, as a highly optimised curl would, and stores the response with its timings, its headers and the IP.
  4. Processing. The status code and the canonical are evaluated, and the links are extracted from the href attributes and go back to the crawl queue.
  5. Render queue. Pages that have returned 200 and don't carry a noindex go in.
  6. WRS. When Google's resources allow it, a Chromium without an interface (headless) opens the page and runs the JavaScript.
  7. Back to processing. The rendered HTML is the one that gets indexed, and links are extracted from it again for the crawl queue.
Diagram of a URL's journey through Google: discovery, crawl queue, robots.txt and crawling; processing, response codes, meta tag extraction, render request and WRS; signal collection, index and SERPs
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.

Diagram of what the Web Rendering Service is according to Google: the crawled HTML and the resources go into the WRS, which returns the rendered DOM tree
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:

Diagram of rendering orchestration at Google: a Renderer with Orchestration, Instrumentation and Metrics Collection layers, a Pool Manager and several Headless Chrome instances
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:

WhatYour ChromeThe WRSSource
NetworkThe 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)
CacheIt obeys your HTTP cache headers.Its own JavaScript and CSS cache of up to 30 days, regardless of those headers.Crawling December (2024)
StateIt 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 videoIt downloads them.It doesn't request them. Nor fonts.Illyes (31 March 2026)
Shadow DOMSeparate trees.It flattens shadow DOM and light DOM in the rendered HTML.JavaScript documentation (updated 4 March 2026)
Randomness and clockMath.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:

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:

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:

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 arrives20182021
Static HTML in the visible tab (exp. 1)IndexedIndexed
Static HTML in a hidden tab (exp. 2)IndexedIndexed
Text fetched by AJAX from an external API during loading (exp. 6)IndexedIndexed
Initial HTML replaced by that AJAX (exp. 5)NoNo
Text from a JS dictionary on the page itself, inserted on load (exp. 4)NoNo
Initial HTML that dictionary was supposed to replace (exp. 3)IndexedIndexed
Text that only arrives with an onClick, from internal JSON or from an API (exp. 8 and 10)NoNo
Static HTML that click would have replaced (exp. 7 and 9)IndexedIndexed
iframe with index,follow (exp. 11)IndexedNo
iframe with noindex,nofollow (exp. 12)NoNo

It boils down to three rules:

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":

MeasurementFigureWho and howWhat it means
Initial window of mobile Googlebot981 × 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 tools1750 px in the Search Console viewer; 10,000 px in the Rich Results Test as desktopMe, at Mario Mangas's suggestion (June 2025)How far the image they show you goes, not what Google processes
Height after resizing1,251,074 pxTony McCreath: two resize events, at around 5 s and 5.3 s on the internal clockHow 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":

Search Console screenshot of a website with the first block at 100vh: the stretched hero background takes up almost the whole image and no text can be seen
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 page in the Rich Results Test: the 100vh hero takes up the screenshot and covers the main content
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:

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.

Search Console screenshot of the same website after adding max-height to the hero: the text now appears
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:

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.

Links, buttons and JavaScript redirects

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 pageDid Googlebot run the fetch?Status in Search ConsoleLast crawl
Meta robots noindex that the JavaScript itself removesYes, via POSTExcluded by noindex20 May 2025
X-Robots-Tag: noindex headerYes, via POSTExcluded by noindex22 June 2025
404 status codeNoNot found (404)22 June 2025
Meta robots noindex with JavaScript redirectYes, via POSTExcluded 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:

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 Sources panel with the Snippets tab open and the first lines of the detector script pasted into 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.

DevTools Network tab with throttling set to 3G and the Disable cache box ticked
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:

Context menu of a DevTools snippet with the Run option first
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:

DevTools console with the detector's output: the meta robots didn't exist, it is added to the DOM as INDEX, FOLLOW and stays under observation
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:

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 documentation on pagination: it recommends linking pages in sequence and says Google tries to recognise and index them
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:

  1. 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.
  2. 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:

SourceWhat it measuresFigure
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 2019From crawl to having the page renderedMedian of 5 seconds. 90th percentile, "within minutes"
Google, SEO on the Beach 2023Until the page is renderedMedian of 5 seconds; the slowest 10%, a few minutes
Google, 2024 interviewFrom crawl to renderMinutes for most pages, sometimes hours and very rarely longer
Google, Andalu-SEO 2026Render queue versus crawl queue, with their logs90% of URLs spend only a few minutes in the render queue. The hours or days are lost in the crawl queue
Google documentationWait in the render queueA 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.org25th 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 resourceAbout 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.

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 HTML in Search Console with the snapshot-counter meta tag at 5
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:

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):

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:

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:

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 SEO Spider rendering configuration with the AJAX timeout at 5 seconds and the notice that Googlebot is more flexible
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.

HTTP response of the crawled page in Search Console, with the header Date: Sat, 01 Nov 2025 06:24:00 GMT highlighted
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 made-up meta tags as shown by Search Console: user-date 05/11/2025 21:14:51, user-date-js 04/11/2025 16:00:05 and snapshot-counter 5
The three meta tags in the crawled page's HTML, in Search Console.

Each meta tells you something different:

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:

Crawled page in Search Console's URL Inspection with user-date 11/01/2025 07:24:00 and user-date-js 31/10/2025 17:00:05
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:

Live test in Search Console with user-date 04/11/2025 12:25:13, user-date-js 04/11/2025 03:25:16 and snapshot-counter at 5
"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:

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.

Diagram of how a website works: how a page travels from the server to the browser
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:

TypeDescriptionSEO advantagesConsiderations
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.
HybridWhat 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 renderingCSR 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 diagram: the user's browser downloads the JavaScript and builds the page
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.

JavaScript rendering configuration in Screaming Frog
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:

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 diagram: the server renders the JavaScript and sends the HTML already assembled
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 diagram: the HTML is generated at deploy time and reused on every request
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:

Hybrid rendering diagram: part of the JavaScript is processed on the server and part in the user's browser
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 diagram: users receive the CSR version and crawlers a prerendered HTML version
Dynamic rendering: two different paths depending on who requests the page.

Its history is that of a recommendation that expired:

  1. In 2019 Google presented it as an option to consider if your website relied heavily on client-side JavaScript.
  2. In August 2022 it updated its documentation to say that it's a workaround and not a long-term solution.
  3. 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".
Screenshot of the August 2022 update to Google's documentation on the problems of dynamic rendering
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 report of a website with Incremental Static Regeneration
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:

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:

  1. The URL must be crawlable, and so must your scripts: Google doesn't run JavaScript from files blocked by robots.txt.
  2. The URL must be indexable in the initial HTML. A noindex at source can't be fixed with JS.
  3. The canonical must be correct at source: self-canonical or none.
  4. There must be some way to insert the script (it's usually easier than it seems).
  5. The script must run after the element you want to change exists. A defer also works.
  6. 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:

Custom script inserted in a Google Tag Manager tag
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.

Ahrefs Patches feature within Site Audit for modifying elements of a website without writing JavaScript
Patches, within Ahrefs Site Audit.

The limits of the patch

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:

Ahrefs Page Inspect showing the final rendered HTML of a page
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.

ToolWhat it answersWhat it doesn't answer
URL Inspection, indexed version ("View crawled page")What HTML, headers, console and resources Google has from the last crawlWhat 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 screenshotWhat is indexed, which canonical Google will choose, whether it's a duplicate
Rich Results TestThe same as the live test, on other people's websites and on desktop tooNothing about the index
Server logs and crawl statsWhich URLs and resources Google actually requestsWhat it did with them when rendering
Dentsu's Fetch & RenderThe screenshot of the whole pageIt isn't Google: no guarantee the result is the real one
Screaming Frog, Ahrefs Page InspectDifferences between initial and rendered HTML, on many URLs at onceThey aren't Googlebot: different IP, different Chrome, different timings
Your browserWhat depends on JavaScript and what changes in the DOMWhat 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:

ConditionLive testReal Googlebot (indexing)
Resource cacheRequests fresh resourcesUses its cache: JS and CSS up to 30 days old
ClockReal timeStarts at midnight UTC
AgentGoogle-InspectionTool (Mozilla/5.0 (compatible; Google-InspectionTool/1.0) on desktop), with screenshotGooglebot, without screenshot
IPAccording to the documentation, the ranges in common-crawlers.json, the same as GooglebotThe ranges in common-crawlers.json
Maximum wait on a page that keeps requesting dataBetween 48 and 54 seconds in one published testAbout 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).

Test page with cut marks every so many pixels seen in the Search Console rendering viewer
One of the pages with pixel marks, in the Search Console rendering viewer.
Second test of the Search Console screenshot cut-off, which ends at the 1750-pixel mark
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:

Google Rich Results Test with the option to test the URL as desktop
In the Rich Results Test you can choose to test as desktop.
Desktop screenshot from the Rich Results Test, which reaches 10,000 pixels in height
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 Fetch and Render interface with the full rendering of a page, with no height limit
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:

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:

  1. 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.
  2. Compare Ctrl+U with the element inspector: the HTML that arrives from the server versus the DOM after the JavaScript.
  3. 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 -rn

Anyone 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.1

There 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 JavaScript counter installed on my website fails in Bing's crawler
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:

Top, what Bing has in its system, without rendering JavaScript; bottom, Bing's live test, which does render it
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 visitsWhat it doesDoes it run JavaScript?
The chat, when you give it a URLRequests the page at that moment to answer youAlmost never: it reads the HTML the server returns
Background crawlers (GPTBot, ClaudeBot, PerplexityBot…)Go through the web to train models or feed their own indexNo. They download the JS files but don't run them
Google's index (AI Overviews, AI Mode)Retrieves pages from Google's indexNot 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 itYes: 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 on which AI chats render JavaScript
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:

Browser console with the time it takes to inject the value via JavaScript, measured from Spain: about 300 ms
Measurement from Spain: the value is injected at 300 ms.
VPN connected in Melbourne and browser console with the value's injection time measured from Australia
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):

ChatAndre Alpar's analysisMy tests (as of 25 June 2026)
QwenRenders JSRenders JS
DeepSeekRenders JSSometimes
KimiRenders JSSometimes
MistralRenders JSSometimes
GrokRuns JS but ignores the resultDoesn't render
ChatGPTDoesn't renderDoesn't render
ClaudeDoesn't renderDoesn't render
GeminiDoesn't renderDoesn't render
PerplexityDoesn't renderDoesn't render
CopilotDoesn't renderDoesn'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.

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:

"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

Content and links

CSS and window

Resources, cache and robots.txt

How to check it, step by step

  1. Request the URL without JavaScript (curl or Ctrl+U) and look at the status code, the meta robots and the canonical.
  2. 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).
  3. 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.
  4. If the website isn't yours, use the Rich Results Test.
  5. 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.
  6. Check the logs: which resources Googlebot requests and whether your server responds slowly.

Bing and AI

Which strategy to choose, in two questions

Open questions

There are things in this guide that aren't settled:

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

  1. Andalu-SEO (n.d.). Rendering: What, how, why. andalu-seo.es. https://andalu-seo.es/ponente/2026/martin-splitt
  2. 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)
  3. Google Help (n.d.). URL Inspection tool - Search Console Help. https://support.google.com/webmasters/answer/9012289?hl=en
  4. 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
  5. bing.com (n.d.). Bing Webmaster Guidelines. https://www.bing.com/webmasters/help/webmaster-guidelines-30fba23a
  6. 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/
  7. Costello, R. (2019, July 22). How JavaScript Rendering Works. lumar.io. https://www.lumar.io/ebooks/javascript-seo-guide/how-javascript-rendering-works/
  8. Duda (2023, August 22). Exploring the Art of Rendering with Google's Martin Splitt. youtube.com. https://www.youtube.com/watch?v=-newLrArh6c
  9. Google Search Central (2019, May 7). The new evergreen Googlebot. https://developers.google.com/search/blog/2019/05/the-new-evergreen-googlebot
  10. Google Search Central (n.d.). AI features and your website. https://developers.google.com/search/docs/appearance/ai-features
  11. Google Search Central (n.d.). Dynamic Rendering as a Workaround. https://developers.google.com/search/docs/crawling-indexing/javascript/dynamic-rendering
  12. Google Search Central (n.d.). Fix Lazy-Loaded Website Content. https://developers.google.com/search/docs/crawling-indexing/javascript/lazy-loading
  13. Google Search Central (n.d.). Fix Search-related JavaScript problems. https://developers.google.com/search/docs/crawling-indexing/javascript/fix-search-javascript
  14. Google Search Central (n.d.). Generate Structured Data with JavaScript. https://developers.google.com/search/docs/appearance/structured-data/generate-structured-data-with-javascript
  15. Google Search Central (n.d.). Google's common crawlers. https://developers.google.com/search/docs/crawling-indexing/google-common-crawlers
  16. 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
  17. Google Search Central (n.d.). Pagination Best Practices for Google. https://developers.google.com/search/docs/specialty/ecommerce/pagination-and-incremental-page-loading
  18. Google Search Central (n.d.). Understand the JavaScript SEO basics. https://developers.google.com/search/docs/crawling-indexing/javascript/javascript-seo-basics
  19. 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
  20. 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
  21. Miller, J. (2020, August 11). Islands Architecture. jasonformat.com. https://jasonformat.com/islands-architecture/
  22. nextjs.org (n.d.). Streaming (Next.js documentation). https://nextjs.org/docs/app/guides/streaming
  23. nextjs.org (n.d.). generateMetadata (Next.js documentation). https://nextjs.org/docs/app/api-reference/functions/generate-metadata
  24. nextjs.org (n.d.). htmlLimitedBots (Next.js documentation). https://nextjs.org/docs/app/api-reference/config/next-config-js/htmlLimitedBots
  25. Osmani, A. and Miller, J. (2019, February 6). Rendering on the Web. web.dev. https://web.dev/articles/rendering-on-the-web
  26. react.dev (n.d.). renderToPipeableStream (React documentation). https://react.dev/reference/react-dom/server/renderToPipeableStream
  27. 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/
  28. Sánchez, C. (2023, July 10). SEO rendering. sanchezdonate.net. https://sanchezdonate.net/en/article/seo-rendering/
  29. Sánchez, C. (2023, March 16). JavaScript renderings in SEO. sanchezdonate.net. https://sanchezdonate.net/en/article/javascript-renderings-in-seo/
  30. 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/
  31. 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/
  32. 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/
  33. 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/
  34. Sánchez, C. (2025, November 11). Advanced SEO guide to rendering. sanchezdonate.net. https://sanchezdonate.net/en/article/advanced-seo-guide-to-rendering/
  35. 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
  36. 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/
  37. Sánchez, C. (2025, January 22). JS to improve your content. sanchezdonate.net. https://sanchezdonate.net/en/article/js-to-improve-your-content/
  38. Sánchez, C. (2025, November 4). Calculate Google's rendering time. sanchezdonate.net. https://sanchezdonate.net/en/article/calculate-googles-rendering-time/
  39. 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/
  40. Sánchez, C. (2025, November 9). Renderizado. Revisar flashazos de noindex (Spanish). sanchezdonate.net. https://sanchezdonate.net/articulo/curiosidades/revisar-flashazos-noindex/
  41. 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
  42. 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
  43. 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
  44. Schwartz, B. (2026, February 26). Bing Webmaster Guidelines Updated. Search Engine Roundtable. https://www.seroundtable.com/bing-webmaster-guidelines-updated-41002.html
  45. Screaming Frog (2017, January 5). How To Crawl JavaScript Websites. https://www.screamingfrog.co.uk/seo-spider/tutorials/crawl-javascript-seo/
  46. Siddle, R. (2021, July 12). 12 Experiments for Tabbed Content SEO. merj.com. https://merj.com/blog/12-experiments-for-tabbed-content-seo
  47. Smart, D. (2021, September 11). Web Worker Content - Will It Index?. tamethebots.com. https://tamethebots.com/blog-n-bits/will-web-worker-contents-index
  48. 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
  49. 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
  50. 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/
  51. 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/
  52. 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
  53. Splitt, M. (2023, June 18). What rendering really means for SEO - Martin Splitt #SOB23. youtube.com. https://www.youtube.com/watch?v=BU8ZvTq4A6M
  54. 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
  55. 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
  56. 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
  57. 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
  58. Tony (2025, September 5). Tony's Theory of Googlebot Relativity. bigcommerce.websiteadvantage.com.au. https://bigcommerce.websiteadvantage.com.au/tonys-theory-of-googlebot-relativity/
  59. web.dev (n.d.). Build agent-friendly websites. https://web.dev/articles/ai-agent-site-ux
  60. Zarr, O. (2024, December 30). JavaScript SEO Guide for SEOs and Developers. seosly.com. https://seosly.com/blog/javascript-seo/
  61. 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
  62. 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
  63. 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
If you like this article, you would help me a lot by sharing my content:
Training
Interested in Advanced SEO Training?

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
You might be interested in other articles:
SEO Articles