On October 29, Google quietly edited a blog post it published seven months earlier, clarifying that its 2MB crawl limit counts HTTP response headers, not request headers. It's a small correction. It's also a reminder that this limit is real, enforced, and still not well understood by the people whose job it is to catch it before it costs them traffic.
The limit is 2MB. Past it, Googlebot doesn't reject your page, it doesn't flag it, and it doesn't tell you. It just stops reading. The bigger problem is that the main tool SEOs use to check their own pages for exactly this issue was built on a different crawler, with a different ceiling, and it will hand you a clean bill of health on a page that's already being cut off in the index.
What Google's crawl limit actually says
Googlebot fetches at most 2MB of any individual URL, PDFs excluded, according to Google's own crawling explainer, published March 31, 2026 under Gary Illyes' byline. That 2MB figure covers the entire raw HTML response, including the HTTP headers that precede it. Google revised that same post on October 29, 2026, to clarify a detail that matters for anyone measuring byte counts by hand: the 2MB counts HTTP response headers, the ones the server sends back, not the request headers the browser or crawler sends out. Any crawler that doesn't declare its own limit defaults to 15MB, which is a separate, unrelated ceiling for unnamed bots, not a downgrade from some prior Googlebot number.
“Googlebot doesn't reject the page. It stops the fetch exactly at the 2MB cutoff, and any bytes after that threshold simply don't exist to Googlebot.”
Two details in the official post matter more than the headline number. First, the truncated fragment isn't discarded, it's passed to indexing and rendering as if it were the whole file, so a page that gets cut off mid-sentence still gets indexed, just wrong. Second, subresources get their own separate counters: a linked CSS or JavaScript file doesn't eat into the parent page's 2MB budget, but each of those files is capped at 2MB in its own right. A page built from clean, externalized assets is largely protected by that separation. A page with everything crammed inline is not.
The test that caught Google doing it
Spotibo ran the test most SEOs only argue about. On February 9, 2026, developer Janko Januska published a set of files to Google and tracked exactly what happened to each one, with the test pages left live for anyone to check. The point of the exercise wasn't to confirm the number Google had already put in writing. It was to see what actually happens to the file once it crosses that line, because a documented limit and an observed, reproducible failure mode are two different kinds of evidence, and only one of them tells you what your own pages are at risk of.
| TEST FILE | WHAT HAPPENED | SEARCH CONSOLE'S RESPONSE |
|---|---|---|
| 3MB HTML page | Indexed copy cut off at roughly 2MB, around line 15,210, mid-word | Reported "Page is indexed," no warning |
| 16MB HTML page | Google never processed it | Indexing request returned a generic error, crawl data showed N/A |
| 2.5MB image | Indexed normally, appeared in Image Search within two days | No issue, images aren't bound by the HTML limit |
| CSS/JS files over 15MB | Suspected silent truncation, unconfirmed | No errors reported either way |
The 3MB test page is the one that matters. Google indexed it, Search Console called it healthy, and the version actually sitting in Google's index stops roughly two-thirds of the way through the file, mid-word, with no flag anywhere in the interface telling the site owner that happened.
The tool everyone uses to check this says everything is fine
DebugBear founder Matt Zeunert ran a parallel investigation a week later and reached the opposite result using Search Console's own tools. Across five separate checks, Test Live URL on an oversized HTML document, Test Live URL on a page with a large external JavaScript file, a dedicated test page submitted through URL Inspection, and two more built from 2MB-plus DOM content generated by JavaScript, every single one came back showing the complete, untruncated page.
Read those two results side by side and they look like a contradiction. One published test proves truncation happens, with a line number and a dead link to the cut page. Another, equally careful test, run through Google's own verification tooling, finds nothing. Both are accurate. They're measuring two different crawlers.
Why the two tests disagree
Search Console's URL Inspection and Test Live URL features run on a separate crawler Google calls Google-InspectionTool, and both Spotibo and the German technical SEO site seo-kreativ independently report that it operates on a materially higher fetch ceiling than the indexing-time Googlebot fetch the 2MB limit actually governs. That's why Zeunert's tests kept coming back clean: he was running the right test on the wrong crawler.
The practical consequence is that the verification layer and the production layer disagree, and the verification layer wins the argument by default because it's the one with the interface. Search Console tells you a page is indexed. It does not tell you whether the copy it indexed is complete. Those are two different claims, and right now only one of them is checkable from inside Google's own tools.
Who this actually hits
Almost nobody runs into this limit by accident, and that's exactly why it's dangerous. Seobility's pass across 44.5 million pages found only 0.82% exceeding 2MB, and separate HTTP Archive data puts the median mobile page at roughly 33KB with 90% of pages under 151KB. Most sites will never see this number in a report.
The pages that do cross it share a profile: large category and listing pages with hundreds of inline product cards, templates carrying megabytes of base64-encoded images instead of linked files, enterprise navigation markup repeated in full on every page, and JSON-LD blocks dumped inline at full size instead of trimmed or deferred. That's not a random sample of the web. That's the enterprise e-commerce and publisher footprint this site's own audits spend most of their time inside, which makes a quiet, unverifiable truncation bug considerably more expensive than a 0.82% prevalence rate suggests.
There's a second-order effect worth naming directly. A page built from heavy inline markup usually crossed 2MB gradually, one added widget or one new product-card variant at a time, with no single commit that looks dangerous on review. Nobody ships a page that's deliberately 3MB. It accumulates, which means the fix is rarely one bad deploy to revert. It's a budget to defend going forward, the same way page weight and Core Web Vitals became release-gate metrics once teams stopped treating them as someone else's problem.
How to check your own site
Checking for this requires measuring the actual delivered document instead of asking Search Console whether it's happy, because Search Console's happiness is not the question that matters here.
Do this next
Pull the three largest templates on your site, check their actual delivered HTML size with curl, and stop relying on Search Console's green checkmarks to tell you the whole story. If you're running technical seo services for a site with large catalog or listing templates, this is a five-minute check that catches a bug none of the standard tooling will ever surface on its own, which is exactly the gap a proper audit earns its fee by closing. We've written before about how Google shares crawl capacity across every crawler hitting your site, about the rendering gap between Googlebot and the AI crawlers that don't execute JavaScript, and about Google's own published ranges for how long crawling and indexing actually take. This bug sits underneath all three: it's not a ranking problem, it's a measurement problem, and it stays invisible for exactly as long as you keep trusting the tool that can't see it.
See where you are cited today
A free snapshot audit of your rankings and AI citations before we ever talk.
Josh leads work at the intersection of SEO and generative engines at Something Inc., helping B2B brands get ranked and cited across every major AI engine.