Best Residential Proxies: Top Services Side by Side

Under 50 GB a month. Decodo and IPRoyal have the lowest real floors: 3 GB at $3.75/GB, and 1 GB at $7.00 with traffic that never expires. At this size the rate matters less than the ability to stop.

100 GB to 1 TB. Decodo's published $2.75/GB at 100 GB is the cheapest self-serve rate here, with Webshare's configurator running down toward $1.40/GB at 3,000 GB. Bright Data and Oxylabs cost more per gigabyte and sell support and compliance paperwork with it.

Heavy or JavaScript-rendered pages. Per-GB billing is the wrong shape. A 2.5 MB rendered page on a metered plan costs roughly ten times a 250 KB HTML page, for one record either way. Price per request instead: SparkProxy's Scraping API routes through residential exits at 10 credits plain and 25 rendered, and does not care how big the page is.

A raw residential endpoint. Antidetect profiles, logged-in accounts, anything where you drive the session: buy from the vendors above, because a managed API will not do that job.

A target that does not block datacenter IPs. Then do not buy residential at all, the most common expensive mistake in this category. Section nine has the two-minute check.

Nobody here is a strict upgrade over anyone else. The sections below say where each loses.

Six things decide whether a residential plan is good value, and the headline per-GB rate is only one.

1. Published rate at your actual volume, not the "from" price. Most ladders here move by roughly 2x between the entry tier and 100 GB.
2. What happens to unused traffic. Expiring monthly, rolling over, or never expiring. That term beats a 20 cent per-GB difference for anyone with spiky demand.
3. The floor. The smallest amount you can buy and still test properly.
4. Trial terms you can measure with. 100 MB proves connectivity. It does not measure a block rate.
5. Geo granularity and session control. Country only, or city, state and ASN, plus how long a sticky session may hold.
6. Sourcing disclosure and a DPA. Residential traffic exits real consumer devices, so security review will ask where the consent came from.

What this review ignores: vendor success-rate panels. IPRoyal publishes 99.4% success and roughly 0.5s response, SOAX 99.95% and 0.55s, Webshare 99.97% uptime. None was independently audited or measured against your targets. SparkProxy marketing gets the same treatment.

Every row is that vendor's own published material, read 8 September 2026.

Decodo

The cheapest published self-serve ladder here: $3.75/GB at 3 GB, $3.50 at 10, $3.25 at 25, $3.00 at 50 and $2.75 at 100, with enterprise steps at $2.50, $2.25 and $2.00 for 250, 500 and 1,000 GB. Pay as you go is $4.00/GB, unlimited concurrent sessions are included, and geo-targeting carries no separate fee.

Buy it when you want the lowest rate without talking to anyone and a 14-day money-back window beats a long trial. Skip it when you need to evaluate first: the trial is three days on a 100 MB allocation, roughly 400 HTML pages.

Webshare

The only ladder here reaching $1.40/GB, at 3,000 GB. The other end is $3.50/GB at 1 GB, and the rate in between comes from the configurator rather than a published table, so a 100 GB buyer prices it themselves. The free tier is 10 proxies with up to 1 GB a month and no card, the most useful free access here because you can point it at real targets today.

Buy it when your volume is large and steady enough to sit near the bottom of the ladder. Skip it when you need one published number for a budget, or the discount curve never engages at your size.

Bright Data

The widest published footprint of the six: over 400M monthly residential IPs across 195 countries. Pricing on 8 September 2026 was displayed with a 50% coupon applied: pay as you go struck through from $8 to $4.00/GB, and monthly plans at $499 for 141 GB, $999 for 332 GB and $1999 for 798 GB, shown at $3.50, $3.00 and $2.50 per GB. Above 1 TB, the page sends you to sales.

Buy it when you need coverage nobody else has, or procurement wants a large vendor with full compliance documentation. Skip it when you want a simple bill: the list rate is double the coupon rate, so model month four, not month one.

Oxylabs

The most enterprise-shaped of the group. Published tiers run Starter 5 GB at $6/GB ($30), Basic 20 GB at $5/GB ($100), Advanced 125 GB at $4/GB ($500) and Corporate 1 TB at $2.50/GB ($2,500), on a claimed 175M+ pool across 195+ countries, with IPv4 and IPv6 selection, 24/7 support and top-ups to 2 TB.

Buy it when you want a named account manager and clean invoicing more than the lowest rate. Skip it when you are price-sensitive: at 100 GB it costs roughly 45% more per gigabyte than Decodo's published rate, and the trial needs a contact form rather than a signup.

IPRoyal

Sells traffic that does not expire, a genuinely different product from the same unit. Subscription rates are $7.00/GB at 1 GB, $5.95 at 2 GB and $5.25 at 10 GB, pay as you go $7.35, $6.25 and $5.51 at those steps, and custom pricing reaches $1.75/GB with a 10 TB minimum. The pool claim is 64M+ IPs across 195+ countries, with per-country counts published including 3.45M in the US.

Buy it when demand is spiky and you hate watching allowances evaporate at month end. Buying 20 GB once and drawing it down over a year is a real advantage. Skip it when you are steady and high-volume: the published mid-ladder rates are the highest here, and $1.75 is out of reach below 10 TB.

SOAX

Sells credits rather than gigabytes, at one rate across residential and mobile, with the per-GB draw varying by country tier. Published plans are Sandbox (free), Builder $200 at a $3.00/GB tier-1 draw, Team $500 at $2.20/GB, Scale $1,500 at $1.50/GB and Enterprise $3,000 at $0.85/GB, with Enterprise volume steps of $0.85, $0.75 and $0.50 across 0-5 TB, 5-15 TB and above. Credits expire in 60 days monthly, 365 annually. The claimed pool is 155M+ IPs across 195+ geos with city-level targeting.

Buy it when you mix residential and mobile in one workload and want one meter instead of two. Skip it when traffic is bursty, because 60-day expiry cancels most of the flexibility credits normally buy, and the trial is $1.99 for 400 MB.

Everything above prices a gigabyte. Nothing above tells you how many gigabytes you need, and that gap is where budgets break. The useful metric is bytes per usable record, and almost nobody measures it before signing up. Three things inflate it:

• Page weight. A product listing page is 150 to 400 KB of HTML. Drive it with a real browser and you pull scripts, fonts, images and beacons too, commonly 2 to 4 MB.
• Failed requests. A block page, a CAPTCHA interstitial and a 429 all transfer bytes, and every metered plan here bills them. A 25% block rate is a 25% price increase, exactly.
• Retries and redirects. Each retry is a full second fetch. Two retries on a fifth of your requests adds about 40%.

Pull 200 pages, sum the response bodies, divide by the records you actually extracted:

import requests

PROXY = "http://USER:PASS@gateway.sparkproxy.io:11000"
proxies = {"http": PROXY, "https": PROXY}

total_bytes, records = 0, 0
for url in target_urls[:200]:
    try:
        r = requests.get(url, proxies=proxies, timeout=20)
        total_bytes += len(r.content)          # blocked responses count too
        if r.status_code == 200:
            records += extract_count(r.text)   # your parser
    except requests.RequestException:
        pass

print(f"KB per usable record: {total_bytes / max(records, 1) / 1024:,.1f}")

Multiply that by your monthly record target, divide by 1,048,576, and you have the only gigabyte figure worth budgeting against. Our piece on bandwidth in proxy services covers what counts as billable transfer.

Two workloads, priced through every published ladder above. These are model assumptions chosen to be plausible, not measurements from a test we ran. Your numbers will differ. The shape is the point, not the totals.

Workload A: 500,000 plain HTML fetches, roughly 200 KB each, about 95 GB of transfer.

On light HTML, per-GB billing wins outright and SparkProxy is the worst buy on the page. Now change one variable.

Workload B: 200,000 JavaScript-rendered product pages, roughly 2.5 MB of transfer each, about 488 GB.

Same vendors, opposite result, and nothing changed except page weight. Break-even sits at roughly 250 to 400 KB per request depending on which per-GB rate you compare against: below that buy gigabytes, above it buy requests. Add SparkProxy's country_code parameter, 5 extra credits, and break-even moves up to roughly 400 to 550 KB. One quieter difference in workload B: the per-GB rows assume you run and pay for your own browser fleet. The per-request row does not.

Bright Data publishes 400M+, Oxylabs 175M+, SOAX 155M+, Decodo 115M+, Webshare 80M+, IPRoyal 64M+. Ranking those is close to meaningless, for three reasons.

They count different things. Most are monthly unique IPs seen across a peer network, not addresses available concurrently, and the number of exits you can reach at 3am in Belgium is smaller by orders of magnitude. None is independently audited. They are vendor marketing, reproduced here as vendor marketing. And your workload never touches the whole pool: if you need US addresses, IPRoyal's published 3.45M US figure tells you more than anyone's global total, and it is the only per-country breakdown published openly here.

What varies between these pools is behaviour, not size: how fast addresses recycle, whether a sticky session survives a full checkout flow, and how many exits in your country are already burned by other customers hitting the same site. None of that is visible from outside, which is why the test section exists. For the mechanics, see rotating vs static residential proxies and what a sticky session proxy is.

Every service above meters bytes. SparkProxy's Scraping API meters requests, and its premium_proxy parameter routes through residential exits, so the IP is priced per call: 10 credits plain, 25 with rendering, plus 5 for country targeting.

curl -G "https://scrape.sparkproxy.io/api/v1" \
  -H "X-API-Key: YOUR_API_KEY" \
  --data-urlencode "url=https://example.com/product/123" \
  --data-urlencode "premium_proxy=true" \
  --data-urlencode "render_js=true" \
  --data-urlencode "country_code=US" \
  --data-urlencode "format=json"

Credit tiers are Starter $49 for 250,000 credits at 50 concurrent, Growth $99 for 1,000,000 at 100, Pro $249 for 3,000,000 at 200 and Scale $599 for 8,000,000 at 400. Responses carry X-Credits-Used and X-Duration-Ms, so you can cost a job before scaling it. The 1,000 free credits, no card, buy 100 residential fetches or 40 rendered ones: enough to see whether residential exits change your block rate at all.

Three honest limitations. It is not a raw proxy endpoint, so you cannot point an antidetect browser or your own Playwright instance at a residential IP through it. Light HTML at volume is cheaper per gigabyte, as workload A showed. And your plan's concurrency ceiling, not the pool, caps throughput. Full trade-off: scraping API vs self-managed proxies.

Residential traffic costs many times what datacenter traffic costs on the same workload, and a large share of buyers never test whether they need it. Run this first:

curl -s -o /dev/null -w "%{http_code}\n" \
  -x http://USER:PASS@gateway.sparkproxy.io:11000 \
  -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)" \
  https://your-target.example/product/123

If clean datacenter IPs return 200 with sensible pacing and normal headers, buy datacenter and keep the difference. SparkProxy sells that side flat rather than metered: Starter $75/mo for 100 threads, Core $140 for 250, Boost $240 for 500 and Plus $440 for 1000, unlimited bandwidth on all of them, 5 to 25 whitelist slots by plan, 30 day validity, on 1M+ IPs across 80+ countries including 50,000+ US addresses at gateway.sparkproxy.io (11000 for HTTP and HTTPS, 11002 sticky, 13000 SOCKS5). Fair usage sets a per-plan speed ceiling of 25, 50, 100, 150, 200 and 250 Mbps from Starter through Pro+, a ceiling rather than a promised rate.

If datacenter IPs get 403s on the first request regardless of headers, that is ASN-level blocking and residential is the correct purchase. Most real deployments end up mixed: datacenter for discovery and pagination, residential only for the pages that need it. That pattern is in combining datacenter and residential proxies, and the category difference in residential vs datacenter proxies.

Do not buy on a comparison table, this one included. Five of the six services here have a free tier or a trial under $2, so measure first.

Step one, 15 minutes: does the category help? Run the same 100 URLs through a datacenter IP and a residential trial, then compare status codes. If the block rates land within a few points of each other, you just saved four figures a year.

Step two, 30 minutes: measure bytes per usable record. Use the snippet above. That number turns every per-GB price here into a monthly bill, and almost nobody has it when they sign.

Step three, 45 minutes: hold a session. Open a sticky session, run your full flow including the step that usually fails, and count how often the exit changes mid-flow. Pool claims say nothing about this, and it is what breaks checkout and login work. The procedure is in our proxy testing guide, the wider checklist in what to evaluate when selecting a proxy service.

Three measurements, one afternoon, and you know which of these seven options fits your workload. That beats any ranking, this one included.