fundamentals
Rendered HTML vs. view-source: what Googlebot reads
View-source shows what your server sends. Googlebot reads something different. Here's the gap, why it exists, and how to see what Google actually indexes.
Every SEO conversation about page size eventually runs into the same misunderstanding. Someone checks view-source, sees 35KB of clean HTML, and concludes they're fine. They often aren't. The number Googlebot actually cares about can be ten times what view-source shows, and that gap is where most page-weight problems hide.
The two HTMLs
Every web page has two versions of its HTML.
The first is what the server sends in response to a request. This is what curl https://example.com returns, and what your browser shows when you choose View Source. It's static text, with no JavaScript executed yet and no DOM constructed.
The second is what exists in the browser's DOM after JavaScript runs, after the framework hydrates, after any client-side rendering completes. That's what you see in DevTools' Elements panel, and that's what Googlebot indexes.
On a plain HTML page with no JavaScript, the two are identical. On a modern React, Vue, or Svelte app, they can be radically different.
Why the gap exists
Modern web frameworks do two things that inflate rendered HTML beyond what view-source shows.
The first is hydration payloads. Server-rendered React (Next.js, Remix) sends both the HTML and the data the client needs to re-attach interactivity. That data lives inline in the HTML, usually in a <script> tag with an ID like __NEXT_DATA__ or __NUXT__. View-source captures it. But if the framework also fetches additional data and inlines it post-render, you'd miss it.
The second is client-side DOM construction. SPAs that hydrate fully on the client can build entire sections of the page from JSON after first paint. That content exists in the DOM (Google sees it) but never appears in view-source, which only shows the initial server response.
A React e-commerce site might serve a 40KB shell from the server, then construct 600KB of product cards and reviews in the DOM. View-source says 40KB. Googlebot indexes 640KB. The 2MB limit applies to the 640KB number.
For a deeper look at what specifically counts and what doesn't, see our .
How to see your rendered HTML
There are three reasonable ways to see what Googlebot sees.
Chrome DevTools is the most accurate. Open the page, open DevTools, right-click the <html> tag in the Elements panel, choose Copy, then Copy outerHTML. Paste that into a character counter or save it as a file. The byte count is your rendered HTML size.
Google's URL Inspection Tool gives you the authoritative number. In Search Console, go to URL Inspection, run Test Live URL, then View Tested Page and look at the HTML tab. That's the exact HTML Google's renderer captured.
does the same thing as DevTools but automated. We load the URL in a real headless browser, wait for JS, and return the byte count. Faster than Search Console for routine checks.
Common surprises
When people first measure their rendered HTML, certain reactions come up over and over.
"We have 3MB of HTML? But view-source is 50KB."
You're looking at a JS framework with a large hydration payload. The bulk is probably __NEXT_DATA__, an Apollo cache, or Redux state serialized into the page.
"Why is rendered HTML smaller than view-source?"
Rare, but it happens when JavaScript removes DOM nodes after load (collapsing accordions, hiding elements). Not common, not a problem.
"Our staging site is fine but production is 2.5MB."
Something on the production rendering path (analytics, A/B testing, personalization) is injecting DOM that doesn't exist in the development build.
What changes when you measure rendered HTML
Once you know the actual rendered size, a few things tend to follow. You stop trusting view-source for size checks; it's now one signal among several. You start looking at the hydration payload specifically, because on most JS-framework sites that accounts for 60–90% of the size problem. And you realize the 2MB limit is much closer than you thought, even for sites you'd consider lean.
If you find yourself in that last bucket, our covers what to cut first.
View-source still has its uses: debugging server output, checking SSR templates, verifying initial-paint content. Just don't use it to estimate what Google indexes. For that, you need the rendered number.
Check your page size now
Test any URL against Google's 2MB Googlebot HTML limit in seconds.
Run a check
