Headless Browsers Are Not Free: What Puppeteer Costs in Proxy Bandwidth

Covered Hyper Solutions

A headless browser downloads the whole page, and a per-GB proxy bills every byte of it. HTTP Archive's crawl of October 2026 put the median desktop home page at 2,987 KB. Load 100,000 of those through a residential proxy and you move about 306 GB. At our one-GB rate, that is at most $153 before the volume steps.

The tail matters more than the median. One desktop page in ten weighed over 12.5 MB, and protected pages run heavier still. Below are the numbers from HTTP Archive, a partner's benchmark of a protected flow, and the ways to cut the bill without breaking the job.

How much does a headless browser download per page?

About 3 MB, and the figure keeps growing. HTTP Archive loads millions of home pages every month and records what each one transfers. Its median desktop page nearly doubled in ten years:

HTTP Archive's own Web Almanac says the growth "is accelerating". Most of the weight sits in parts a data job rarely reads:

Medians by type do not add up to the total median, so read the bars as proportions. The pattern is plain enough: the HTML document is about one percent of the page. Images and fonts together come to roughly two fifths.

Home pages are a fair proxy for inner pages, though a little heavy. The 2025 Web Almanac measured both: images came to 1,059 KB on home pages and 911 KB on inner pages, and JavaScript to 697 KB and 632 KB.

What does that cost on a per-GB proxy?

Multiply the page weight by the number of loads. Proxy networks bill in decimal gigabytes, and HTTP Archive counts a kilobyte as 1,024 bytes, so 100,000 median desktop pages come to about 306 GB:

At our one-GB residential rate of $0.50/GB, those volumes cost at most:

• HTML only: $1.80 for 100,000 documents.
• Median page: $153.
• 75th percentile page: $308.50.
• 90th percentile page: $641.

These are upper bounds. Residential Lite steps down from 100 GB, falling to $0.44/GB at 2,000 GB+. The gap between the lines stays, whatever the rate: the browser buys the whole page, and the HTML is a sliver of it.

What does a month of scraping cost?

Take a common job: checking 1,000 product pages once a day for 30 days. That is 30,000 page loads. At the October 2026 median, three ways of running it move very different amounts:

The middle line assumes blocking removes the two fifths that images and fonts make up at the median. Your pages will differ, so measure them, as the next section shows. Scale the job by ten and the bill scales with it, though from 100 GB the lower Lite steps apply.

How do you measure your own bytes per page?

Count them in the browser while the job runs. Playwright reports the size of every finished response through request.sizes(). Its responseBodySize is the received body, encoded, and responseHeadersSize counts the headers. Add both for every request of a page load:

// Playwright: bytes one page load received, bodies and headers
const sizes = [];
page.on("requestfinished", (req) => sizes.push(req.sizes()));
await page.goto(url, { waitUntil: "networkidle" });
const all = await Promise.all(sizes);
const bytes = all.reduce((n, s) => n + s.responseBodySize + s.responseHeadersSize, 0);
console.log(url, (bytes / 1e6).toFixed(2), "MB");

Run it on a sample of your real targets, with and without blocking, and multiply by your monthly loads. Then compare the total with what your proxy dashboard shows for the same run. A handful of heavy pages usually explains most of a surprising bill.

Why does a protected page cost even more?

A page behind bot protection loads the protection too: a sensor script, a challenge, sometimes several rounds of each. Hyper Solutions, a partner of ours that sells bypass APIs, measured one protected flow both ways. It was a real airline award-availability search, with "full page loads with all resources" on the browser side:

That is about 19 times the traffic for the same data. Its Akamai page puts the per-solve traffic at about 8 KB through the API against 3 to 12 MB in a browser. It also quotes 240 or more requests per second per worker against 1 to 2.

Weigh these figures with care. They come from one flow, published by a company that sells the faster option, and we have not reproduced them. They match the shape of HTTP Archive's numbers, though: a protected flow in a browser lands between the 75th and the 90th percentile of ordinary pages.

How do you cut the traffic?

Start with the cheapest bytes, the ones you never download.

1. Fetch the data where it lives. If the HTML or a JSON endpoint holds the data, an HTTP client gets it without the page around it. At the median, that is 35 KB against 2,987 KB.
2. Block what you do not parse. On a site without bot protection, abort images, fonts and media. That is roughly two fifths of the median page.
3. Open the session once. Let the browser earn the cookies, then reuse them in a lighter client for the pages that follow.
4. Watch the heavy tail. One page in ten weighs over 12.5 MB. Log the bytes per page, and the expensive targets stand out within a day.

Both browser tools block requests natively. In Playwright, route.abort() drops a request before it goes out:

// Playwright: abort images, fonts and media before they load
await page.route("**/*", (route) => {
  const type = route.request().resourceType();
  if (type === "image" || type === "font" || type === "media") return route.abort();
  return route.continue();
});

Puppeteer does the same through request interception. Once it is on, every request waits until your handler continues or aborts it:

// Puppeteer: the same filter through request interception
await page.setRequestInterception(true);
page.on("request", (req) => {
  const type = req.resourceType();
  if (type === "image" || type === "font" || type === "media") req.abort();
  else req.continue();
});

Blocking has a cost on protected sites. Browserbase's documentation says it "is not recommended on sites with bot protection", because "many bot protection systems rely on image and font loading to verify browser behavior". It reserves the trick for sites without protection. Test a blocked setup on each target before you scale it.

Is a solver API cheaper than a browser farm?

On traffic, clearly. At 100,000 protected loads, Hyper Solutions' numbers put the browser at about 654 GB and the API at about 34 GB. At our one-GB rate, the gap is up to $310 of residential traffic.

The API charges for solves, though. Hyper Solutions bills €3 per 1,000 solves pay as you go, with monthly plans from €1.00 per 1,000 for Akamai. Two details keep this from being a simple subtraction:

• The currencies differ. Our traffic is priced in dollars and the solves in euros, and we use no exchange rate here.
• A solve can serve many pages. Once a session is trusted, its cookie covers many requests. You buy solves per session, while the browser pays full page weight on every load.

So the traffic an API saves is in the same range as the fee it charges, before you count the machines. Hyper Solutions' figure of 1 to 2 requests per second per browser worker is the part that decides big jobs, because it sets how many machines you rent.

When is the browser still the right tool?

A solver API covers specific protection vendors, and an HTTP client covers pages that hand over their data. Everything else is a browser job:

• The data appears only after scripts run. Something has to execute the JavaScript.
• The work is interactive. Forms, logins and checkouts need a real page state.
• The volume is small. At a few thousand loads a month, the gigabytes are noise and the simplest stack wins.
• The protection is not one an API covers. Then the browser is the tool you have.

When you do run browsers, run them on traffic you can measure. Our Playwright guide shows the proxy setup, and the residential proxy price study compares what a gigabyte costs elsewhere.

What this page could not check

• We measured no page loads ourselves and tested no proxy, ours included. Every byte figure comes from HTTP Archive or Hyper Solutions.
• HTTP Archive measures home pages, once a month, from its own crawler. Inner pages, logged-in pages and pages behind a challenge weigh differently.
• Medians by type do not add up to the total median, so the shares above are rough.
• Hyper Solutions' figures come from one flow, published by a company that sells the alternative.
• Our spend figures use the one-GB rate, so they are the most you would pay; volume steps lower them. We will check every number again by January 23, 2027.

Sources

• HTTP Archive, page weight reports (bytesTotal and by resource type), crawl of October 1, 2026, read October 23, 2026.
• HTTP Archive, the bytesTotal query: bytes divided by 1,024, home pages only.
• HTTP Archive, Web Almanac 2025: Page Weight, January 15, 2026.
• Hyper Solutions, homepage benchmark and pricing, and its Akamai page, read October 23, 2026. A partner of ours that sells bypass APIs; not linked here.
• Browserbase, Cost optimization documentation, modified October 8, 2026.
• Playwright, Request class: request.sizes(), read October 23, 2026.
• Playwright, Network: abort requests, read October 22, 2026.
• Puppeteer, Request interception, read October 22, 2026.
• HProxy price catalog: residential Lite and Premium ladders, read October 23, 2026.