Our own visit statistics are always on. Google Analytics, which helps us understand how people use our public pages (not your signed-in workspace), is enabled only with your permission. See our Privacy policy.

EveryInfra
Search⌘K
English
Sign inStart for free
Sections · 11
  1. 01Why measure bytes first
  2. 02Pass and fail criteria, written before the test
  3. 03Test 1: bytes per method
  4. 04Test 2: without a proxy, which store do you see?
  5. 05The cost of 1,000 product pages
  6. 06The success rate you need
  7. 07Who does what: IPFoxy or a data API
  8. 08How to cite this data
  9. 09When these results do not hold
  10. 10Further reading
  11. 11References

How Much Proxy Traffic Does an Amazon Page Use?

We measured the bytes of 40 Amazon product page requests and 6 full browser loads, priced them at IPFoxy's per-GB list prices, and compared the cost per 1,000 pages with a data API. The result depends on how you fetch, which plan you buy and how often requests succeed.

Illustration: a browser window that shows a product page sits on a scale. Data packets flow out through a pipe with a gauge, which stands for metered proxy traffic. A stack of coins is next to the scale.

Rotating residential proxies are sold per GB. So the number of bytes that one page downloads sets the proxy cost of that page. On October 24, 2026, from 18:30 to 18:41 Singapore time, we measured 40 requests for Amazon US product pages and 6 full browser loads. With HTML only, the median page was 0.44 MB. With a full headless browser load, the median was 7.96 MB, 18 times more. At the list prices of IPFoxy rotating residential proxies, the traffic for 1,000 pages costs from $0.88 to $47.71. The same page from a data API costs $1.39 per 1,000 calls.

This article puts proxy traffic cost and data API cost on the same scale. Which one costs less depends on how you fetch, which plan you buy and how often your requests succeed. Each number below has a source, and you can download the raw data.

Horizontal bar chart of the median bytes transferred to get one Amazon product page, by method: EveryInfra product JSON 0.004 MB (no proxy); HTML only with curl and gzip 0.442 MB, 16 pages, range 0.213 to 0.496 MB; headless Chrome with images and fonts blocked 3.44 MB, 3 pages, range 3.43 to 4.03 MB; headless Chrome full page load 7.96 MB, 3 pages, range 4.15 to 13.60 MB. Measured on October 24, 2026, from a Singapore broadband line with no proxy.

Why measure bytes first

IPFoxy sells rotating residential proxies by traffic. On October 24 its pricing page listed six plans: 1GB, 10GB, 50GB, 100GB, 500GB and 1000GB. The price per GB goes from $5.99 down to $1.99, and the plans are valid for 30 to 180 days. Above 1000GB there is a custom plan "from $0.60/GB" (IPFoxy rotating residential pricing). The IP pool covers more than 200 countries and regions (IPFoxy locations). For a product billed by traffic, cost = bytes downloaded × price. The price is on the website. The bytes you must measure.

There is no single answer to "how heavy is a page". The HTTP Archive Web Almanac 2025 defines page weight as all the bytes that a browser downloads to show a page. It also reports that images take the most bytes (Web Almanac 2025: Page Weight). But a data collection script does not always download images. HTML only and a full browser run differ by an order of magnitude. So we measured three common methods.

Pass and fail criteria, written before the test

Before the test, we wrote down three rules:

  1. The unit of comparison is "the data of one product page". Pass: each method gets at least 3 real product pages (the title is a product name, not a block page).
  2. We count bytes on the wire, not decompressed size, because proxies bill transferred traffic. For HTML we add curl's size_download and size_header (curl manual, --write-out; Everything curl: write-out variables). For the browser we add Network.loadingFinished.encodedDataLength for each request from the Chrome DevTools Protocol (CDP Network domain).
  3. We use 1 GB = 10⁹ bytes (NIST prefixes for binary multiples). If a provider counts 1 GB as 2³⁰ bytes, each cost below is about 7% lower.

Result: all three methods pass rule 1 (16 HTML pages, 3 pages for each browser method). Rules 2 and 3 are applied below.

Test 1: bytes per method

We tested from a home broadband line in Singapore, with no proxy. The products come from one search: the Amazon keyword search API for air fryer, first 20 ASINs (18:30, 31.6 seconds, charged $0.001389).

HTML only. We requested /dp/<ASIN> with curl, normal browser headers and Accept-Encoding: gzip, deflate, br (MDN: Accept-Encoding), 4 seconds apart, in two rounds of 20. Amazon sent gzip (RFC 1952), not Brotli (RFC 7932). For the 16 real product pages, the median transfer was 441,688 bytes, the minimum 213,178 and the maximum 496,482. Decompressed, the pages were 1.08 to 2.68 MB.

Headless browser, full load. We opened 3 product pages in the new Chrome headless mode (Chrome headless docs), with the cache off, and waited 15 seconds per page. The three pages used 13.60, 4.15 and 7.96 MB, with 224 to 270 requests each. On the first page, images used 7.03 MB (52%) and scripts 3.02 MB. In DevTools, "transferred size" and "resource size" are different numbers; we use the first one (Chrome DevTools network reference).

Headless browser, images and fonts blocked. Many scripts block images. Both Playwright and Puppeteer document how (Playwright: Network; Puppeteer: request interception). With images and fonts blocked through CDP Network.setBlockedURLs, the three pages used 4.03, 3.44 and 3.43 MB. Scripts were most of the rest: about 3.0 MB, or 87%.

MethodSampleMedian transfer per pageRange
HTML only (curl, gzip)16 pages0.442 MB0.213–0.496 MB
Headless Chrome, images and fonts blocked3 pages3.44 MB3.43–4.03 MB
Headless Chrome, full page load3 pages7.96 MB4.15–13.60 MB
EveryInfra product JSON (no proxy)1 call0.004 MB—

The two browser rows have only 3 pages each. On two pages, CDP recorded the main document as 0 bytes. So these two rows are lower bounds, not exact values.

Test 2: without a proxy, which store do you see?

The same requests show one more thing: the exit IP decides what the page shows.

  • Round 1, no cookies: 19 of 20 product pages returned HTTP 200, but the body was a 3,781-byte "Click the button below to continue shopping" page. Only 1 was a real product page. All 3 search pages (/s?k=) returned 503.
  • Round 2 started with a visit to the home page for cookies. The first 5 were still interstitial pages. The next 15 were real product pages. Over 40 requests, 16 returned a real page: 40%.
  • All 16 real pages showed the delivery location as Singapore. Two of them said that the item cannot ship to that location.
  • In the browser, amazon.com/s?k=air+fryer ended on a page titled "Amazon.sg : air fryer", the Singapore store.

So to see the prices, delivery and search results of a US shopper, the request must come from a US IP. This is what residential proxies are for. IPFoxy's solutions page lists e-commerce, data collection and ad verification as main uses (IPFoxy solutions). The IPFoxy blog also has a guide to e-commerce data collection (IPFoxy: e-commerce data collection guide). The block pages themselves are small (4,206 bytes with headers). They cost requests and time, not traffic.

The cost of 1,000 product pages

We multiply the medians from Test 1 by 1,000 and by the IPFoxy price per GB for each plan. We assume that every page succeeds on the first try. We do not count retries, the proxy tunnel handshake or upload bytes.

Method1GB plan $5.99/GB10GB plan $4.99/GB100GB plan $2.99/GB1000GB plan $1.99/GB
HTML only$2.65$2.20$1.32$0.88
Browser, images and fonts blocked$20.59$17.15$10.28$6.84
Browser, full load$47.71$39.74$23.81$15.85

The Amazon product details API returns the same page for $0.001389 per call, or $1.39 per 1,000 calls (capability catalog, read at 18:29). Failed or empty calls are not charged. At 18:37 we called it once for B0CYJDVT31. It returned 20 fields in 9.1 seconds, with a JSON body of 3,569 bytes. If you only need list fields (price, rating, rating count, brand), one search call returns 20 products, so 1,000 products cost about $0.07.

Grouped bar chart of the proxy traffic cost for 1,000 Amazon product pages at two IPFoxy plans, the 1GB plan at 5.99 US dollars per GB and the 1000GB plan at 1.99 US dollars per GB: HTML only 2.65 and 0.88 dollars; browser with images and fonts blocked 20.59 and 6.84 dollars; browser full load 47.71 and 15.85 dollars. A dashed line marks EveryInfra at 1.39 dollars per 1,000 calls.

The success rate you need

The table assumes 100% success. Real requests fail, and failures need retries. If the success rate is s, the traffic cost per successful page is about "traffic cost ÷ s" (a failed page is only about 4 KB, so we ignore it). With HTML only, to cost less than the data API you need at least:

  • 1GB, 10GB and 50GB plans: 190%, 159% and 127%. These plans never cost less.
  • 100GB plan: 95%.
  • 500GB plan: 76%.
  • 1000GB plan: 63%.

Without a proxy, from Singapore broadband, we got real pages in 40% of requests. Through US residential IPs the rate will be different. We did not have an IPFoxy account, so we did not measure it and we do not give a number. Use your own success rate in the formula above.

Bar chart of the success rate needed, with HTML only, for proxy traffic to cost less than the data API at 1.39 US dollars per 1,000 calls: 1GB plan 190%, 10GB plan 159%, 50GB plan 127%, these three are above 100% and marked never; 100GB plan 95%, 500GB plan 76%, 1000GB plan 63%. A dashed line marks 100%.

This calculation does not include labor. When you collect pages yourself, you write parsers, change code when the page layout changes, and handle block pages and retries. A data API returns fixed field names, so you skip that work. But a data API covers only the platforms and fields in its catalog. For other pages you still collect yourself.

Who does what: IPFoxy or a data API

From these numbers, our recommendation is:

  • Use IPFoxy for pages that you must open as a user in a given country. Examples: delivery and final price for a US shopper, your own seller account, local ad placements. Also use it for sites that are not in a data API catalog and for pages that need a real browser render. Static residential IPs suit one store or account for a long time; the list price starts at $7.99/month (IPFoxy static residential pricing).
  • Use a data API for platforms and fields that are already in the catalog. It is best for large jobs with fixed fields that go into a sheet or a database. A call to the data API does not need a proxy. A proxy only adds proxy traffic.

To do both in one script, see the "Use with IPFoxy proxies" section of our docs. The Python example uses requests 2.34.2 (PyPI: requests). Your own request goes out through the proxy. The EveryInfra request goes direct, with trust_env = False (Requests advanced usage: proxies; Requests API: Session.trust_env). The proxy address has the form username:password@host:port, and the IPFoxy help center shows a Python setup (IPFoxy: rotating proxy with Python). Its example uses the standard urllib.request library, which also reads proxy environment variables by default (Python urllib.request docs). In Scrapy, set proxy in the request meta (Scrapy: HttpProxyMiddleware).

We did not have an IPFoxy account, so we tested the proxy part of the example with a local mock proxy. The mock opens a tunnel with the HTTP CONNECT method (RFC 9110, section 9.3.6; MDN: CONNECT) and checks the Basic credentials in the Proxy-Authorization header (RFC 7617; MDN: Proxy-Authorization). With the correct password, the example reached ipinfo.io through the mock and then got the EveryInfra product data. With a wrong password, the mock returned 407 (MDN: 407) and the example stopped before it called EveryInfra, so nothing was charged. We also set HTTPS_PROXY to the mock. The mock log still showed only the ipinfo.io request: the EveryInfra request did not go through it.

How to cite this data

  • Raw data: amazon-page-weight-2026-10-24.csv (on GitHub: EveryInfra examples repo, amazon-page-weight-2026-10-24.csv; copy on this site: https://everyinfra.com/articles/proxy-traffic-cost-amazon-product-pages/amazon-page-weight-2026-10-24.csv), 51 rows. Each row is one request or one full page load. The columns are page type, ASIN, method, time, HTTP status, real page (yes or no), bytes transferred, request count and a note.
  • Read time: 2026-10-24, 18:30–18:41 Singapore time (UTC+8). IPFoxy prices were read on the same day.
  • How to check: HTML with curl 8.7.1 and --write-out '%{size_download} %{size_header}'; browser with Chrome 155 in headless mode and CDP, from a Node.js 26 script that uses the built-in WebSocket (Node.js global objects). The script and the chart script are in our GitHub example folder, linked from /docs#with-proxy.
  • Suggested citation: EveryInfra, "How Much Proxy Traffic Does an Amazon Page Use?", 2026-10-24, https://everyinfra.com/en/blog/proxy-traffic-cost-amazon-product-pages (data read 2026-10-24, 18:30–18:41 SGT).

When these results do not hold

  • The sample is small: 16 real HTML pages and 3 pages for each browser method, all from one category (air fryers). Longer pages (more reviews, more variants) use more bytes. The HTTP Archive monthly report shows that page weight changes over time (HTTP Archive: Page Weight report). Measure again in a year.
  • No proxy in the path: through a proxy, headers, the tunnel handshake and redirects add some bytes, and the success rate changes.
  • List prices: the IPFoxy website shows sign-up discounts (17% to 23% from the 10GB plan up). We did not apply them. Check the IPFoxy website for the current price.
  • Compliance is out of scope: we only measured bytes. Amazon's robots.txt does not block /dp/ product pages for generic crawlers. But it blocks the whole site for several named crawlers, such as Scrapy and GPTBot (Amazon robots.txt). Its Conditions of Use (updated 2026-08-14) restrict data mining and robots in the "License and Access" section (Amazon Conditions of Use). Read the terms of a site before you collect from it.

Cost of this test: 3 EveryInfra calls, $0.004167 in total (1 search, 2 product details). Three more requests returned 429 because of the rate limit on the same key; they were not charged. IPFoxy is our partner. The links to IPFoxy in this article have no referral parameters. So we do not mark them as referral links (Google's rules for paid and referral links: Qualify your outbound links). Our partner page is IPFoxy Global Proxy. The numbers here are from the two websites on the day we read them.

Further reading

References

  1. Rotating Residential Proxy pricing, IPFoxy, read 2026-10-24. https://www.ipfoxy.com/pricing/rotating/
  2. Static Residential Proxy pricing, IPFoxy, read 2026-10-24. https://www.ipfoxy.net/pricing/residential/
  3. How to use Rotating proxy through Python?, IPFoxy Help Center, 2025-11-18. https://www.ipfoxy.com/help/docs/bn3BDn
  4. Solutions, IPFoxy, read 2026-10-24. https://www.ipfoxy.net/solution/
  5. Proxy locations, IPFoxy, read 2026-10-24. https://www.ipfoxy.net/country/
  6. E-commerce data collection guide (Chinese), IPFoxy blog, read 2026-10-24. https://www.ipfoxy.net/blog/use-cases/6929
  7. Network domain (loadingFinished, setBlockedURLs), Chrome DevTools Protocol, read 2026-10-24. https://chromedevtools.github.io/devtools-protocol/tot/Network/
  8. Chrome Headless mode, Chrome for Developers, read 2026-10-24. https://developer.chrome.com/docs/chromium/headless
  9. Network features reference, Chrome for Developers, read 2026-10-24. https://developer.chrome.com/docs/devtools/network/reference
  10. curl manual (--write-out), curl project, read 2026-10-24. https://curl.se/docs/manpage.html
  11. Write out, Everything curl, read 2026-10-24. https://everything.curl.dev/usingcurl/verbose/writeout.html
  12. Advanced Usage (Proxies), Requests documentation, read 2026-10-24. https://requests.readthedocs.io/en/latest/user/advanced/
  13. Developer Interface (Session.trust_env), Requests documentation, read 2026-10-24. https://requests.readthedocs.io/en/latest/api/
  14. requests 2.34.2, PyPI, released 2026-05-14. https://pypi.org/project/requests/
  15. urllib.request, Python documentation, read 2026-10-24. https://docs.python.org/3/library/urllib.request.html
  16. RFC 9110, HTTP Semantics, IETF, 2022-06. https://www.rfc-editor.org/rfc/rfc9110
  17. RFC 7617, The 'Basic' HTTP Authentication Scheme, IETF, 2015-09. https://www.rfc-editor.org/rfc/rfc7617
  18. RFC 1952, GZIP file format specification version 4.3, IETF, 1996-05. https://www.rfc-editor.org/rfc/rfc1952
  19. RFC 7932, Brotli Compressed Data Format, IETF, 2016-07. https://www.rfc-editor.org/rfc/rfc7932
  20. CONNECT request method, MDN, read 2026-10-24. https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/CONNECT
  21. Proxy-Authorization header, MDN, read 2026-10-24. https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Proxy-Authorization
  22. 407 Proxy Authentication Required, MDN, read 2026-10-24. https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/407
  23. Accept-Encoding header, MDN, read 2026-10-24. https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Encoding
  24. Web Almanac 2025: Page Weight, HTTP Archive, 2026-01-15. https://almanac.httparchive.org/en/2025/page-weight
  25. Page Weight report, HTTP Archive, read 2026-10-24. https://httparchive.org/reports/page-weight
  26. Network, Playwright documentation, read 2026-10-24. https://playwright.dev/docs/network
  27. Request Interception, Puppeteer documentation, read 2026-10-24. https://pptr.dev/guides/network-interception
  28. Downloader Middleware (HttpProxyMiddleware), Scrapy documentation, read 2026-10-24. https://docs.scrapy.org/en/latest/topics/downloader-middleware.html
  29. Prefixes for binary multiples, NIST, read 2026-10-24. https://physics.nist.gov/cuu/Units/binary.html
  30. robots.txt, Amazon, read 2026-10-24. https://www.amazon.com/robots.txt
  31. Conditions of Use, Amazon, updated 2026-08-14. https://www.amazon.com/gp/help/customer/display.html?nodeId=508088
  32. Developers, IPinfo, read 2026-10-24. https://ipinfo.io/developers
  33. Global objects (WebSocket), Node.js documentation, read 2026-10-24. https://nodejs.org/api/globals.html
  34. EveryInfra capability catalog, GET /api/v1/social/catalog, read 2026-10-24 18:29. https://api.everyinfra.com/api/v1/social/catalog
  35. Qualify your outbound links to Google, Google Search Central, read 2026-10-24. https://developers.google.com/search/docs/crawling-indexing/qualify-outbound-links
  36. Raw data amazon-page-weight-2026-10-24.csv, EveryInfra examples repo everyinfra-agent-plugins, 2026-10-24. https://github.com/everyinfra/everyinfra-agent-plugins/blob/main/examples/proxy-plus-data-api/data/amazon-page-weight-2026-10-24.csv

Reference BL-36