JavaScript Rendering 2026: What Google Docs Say

Google’s JavaScript rendering documentation has been updated four times since 2024. Each update has clarified something and introduced a new nuance. The current state is more favorable to JavaScript-heavy pages than it was two years ago, but the improvements have not eliminated the failure modes. This post is a close read of the current documentation with the practical implications extracted.

Key takeaways

• JavaScript pages process in two phases: phase 1 indexes the initial HTML immediately; phase 2 queues the page for deferred rendering by the web rendering service (WRS), which can take days to weeks depending on crawl budget and WRS priority.
• Phase 2 is not guaranteed: if the initial HTML contains sufficient content to answer the query, Google may never run the JavaScript rendering pass — critical content gated behind JS may never be indexed.
• Dynamic imports are now indexed: content loaded via import() statements and code-split bundles is now processed in phase 2, removing a major failure mode from 2023-2024.
• WRS supports React, Vue, Angular, and most major frameworks: framework compatibility is less of a risk factor than it was two years ago.
• Rendering budget is allocated by page importance: high-value pages get rendering priority; low-value pages may only be processed in phase 1.
• Content behind user interactions still fails indexing: scroll simulation works but click handlers that load critical content are not triggered by the WRS.

What Googlebot actually does with JavaScript

Googlebot processes JavaScript pages in two phases, as documented in the search documentation:

Phase 1: Initial crawl. Googlebot fetches the HTML document, processes the CSS and any render-blocking JavaScript, and indexes the initial HTML. The content that appears in the initial HTML response is what Google indexes in phase 1.

Phase 2: Deferred rendering. For pages where the initial HTML does not contain the full content, Googlebot queues the page for a second processing pass. A web rendering service (WRS) executes the JavaScript and processes the rendered DOM. This phase happens after the initial indexing pass and can take days to weeks depending on crawl budget and WRS priority.

The documentation explicitly states that phase 2 is not guaranteed. For pages where the initial HTML contains sufficient content to answer the query, Google may never run the JavaScript. This is the single most important practical implication from the documentation: if your content loads only after JavaScript executes, Googlebot may never see it in the critical first indexing pass.

What the 2025 and 2026 documentation updates changed

The 2024 documentation introduced the two-phase model. The 2025 updates clarified three things that changed how we audit JavaScript sites:

WRS now handles more JavaScript frameworks. The rendering service that processes JavaScript pages in phase 2 supports React, Vue, Angular, and most major frameworks. This is a significant improvement from 2023, when several frameworks were not fully supported. The practical implication: framework compatibility is less of a risk factor than it was two years ago.

Dynamic imports are now indexed. Content loaded via dynamic import() statements and code-split bundles is now processed in phase 2 if the WRS determines it affects the visible content. Previously, dynamically imported content was often skipped. This change matters for sites using route-based code splitting.

Rendering budget is allocated by page importance. Googlebot assigns rendering priority based on signals including page rank, crawl budget, and the freshness of the content. High-value pages get rendering priority. Low-value pages may be processed only in phase 1. The practical implication: not every page on your site will receive a rendering pass.

What still causes JavaScript pages to fail indexing

Despite the improvements, the documentation still describes specific failure modes that cause pages to be indexed incorrectly or not at all.

Content that loads after a user interaction. If your content requires a click, scroll, or other user interaction to load, Googlebot will not see it in either phase. The WRS does simulate some interactions (scroll events) but not click handlers that load critical content. If the above-the-fold content is gated behind a click, it does not index.

Slow JavaScript execution blocking rendering. If the JavaScript on a page takes more than a few seconds to execute, the WRS will time out and index the pre-JavaScript HTML. Slow framework hydration is the most common cause. The INP fix guide covers hydration performance in detail.

Server-side rendering failure returning empty shells. If the server renders an empty HTML shell and the client-side JavaScript is what fills it, the initial HTML that Googlebot indexes in phase 1 contains nothing. If the WRS times out during phase 2, the page gets indexed as blank.

Robots.txt blocking JavaScript or CSS. If your JavaScript or CSS files are blocked by robots.txt, the WRS cannot render the page correctly. This seems obvious but it remains a common production mistake when developers add path blocks for asset folders without checking the crawl impact.

The audit workflow for JavaScript indexing

Based on the documentation and what we see in production audits:

Test 1: Fetch as Google. In Search Console, use the URL Inspection tool to fetch any JavaScript-heavy page. Click “Test Live URL” to see what Googlebot’s WRS sees after rendering. If the rendered content matches the visible content, the page passes. If the rendered content is missing key text, that is the failure point.

Test 2: Compare initial HTML to rendered HTML. View the page source (not the DevTools elements panel) and save the initial HTML. Compare it against what the URL Inspection tool shows after rendering. Any text that appears only after rendering is at risk of being dropped if the WRS deprioritizes the page.

Test 3: Check robots.txt for asset blocking. Fetch your robots.txt and verify that Googlebot can access all JavaScript and CSS files the page depends on. Blocked assets are a direct rendering failure.

Test 4: Measure hydration time. If the framework hydration takes more than 3 seconds on a cold load, the page is at risk of WRS timeout. Measure with Lighthouse in the Chrome DevTools timeline. The goal is framework hydration under 1.5 seconds for above-the-fold content.

The pages that are still at risk

The documentation update improved support for JavaScript frameworks, but two page types remain systematically at risk:

Single-page application (SPA) routes with client-side routing. If an SPA loads a shell page and then populates content via client-side route changes, each “page” in the SPA is actually the same initial URL. Googlebot sees the initial shell. If the shell contains navigation but not content, and if the WRS does not fully simulate navigation to trigger content loads, SPA routes may not be indexed individually.

JavaScript-gated content blocks. Pages that load the initial content but defer secondary content blocks behind scroll or click handlers. The initial content may index; the deferred content may not.

The JavaScript SEO guide covers the specific fixes for SPA routing and the recommended patterns for making JavaScript content reliably indexable.

What the documentation recommends

Google’s documentation consistently recommends server-side rendering or static generation as the preferred approach for content that needs reliable indexing. The reason is explicit: if the server returns complete HTML, Googlebot does not need to rely on a second rendering pass.

For sites that cannot migrate away from client-side rendering, the documentation recommends:

• Use preload and prefetch hints for critical JavaScript bundles
• Keep the initial HTML meaningful — do not return an empty shell
• Ensure above-the-fold content renders without waiting for JavaScript
• Test rendering in Search Console URL Inspection before publishing

Frequently asked questions

Does Googlebot execute all JavaScript on a page?

No. Googlebot executes JavaScript that affects visible content, but it does not execute code that handles analytics, ads, or third-party scripts that are not relevant to rendering. It also does not simulate all user interactions — if content requires a specific click sequence to load, Googlebot may not execute that sequence.

How long does phase 2 rendering take?

The documentation does not specify an SLA. In practice, high-value pages render within hours to days. Low-value pages may not render at all during the indexing pass. Pages that require rendering and do not receive it appear in search results based on their initial HTML content.

Does serving static HTML instead of JavaScript improve rankings?

Not directly — Google indexes JavaScript pages correctly in most cases. The ranking benefit of server-side rendering comes from faster rendering (better Core Web Vitals) and more reliable indexing, not from a direct ranking signal for static HTML.

How do I know if my page failed phase 2 rendering?

The URL Inspection tool in Search Console shows the rendered HTML. Compare it against what you expect. If the rendered HTML is missing content that appears when you load the page in a browser, the WRS did not fully render the page. Investigate hydration time, JavaScript errors, and blocked assets.

The bottom line

Google’s JavaScript rendering support has improved significantly since 2024. Most well-built JavaScript sites now render correctly. The remaining failure modes — slow hydration, content behind user interactions, and empty shells — are all fixable. Run the audit workflow above on your JavaScript pages and fix the highest-impact issue first.

Use the SEO Analyzer to check for rendering issues across your site.