Best Residential Proxies for Web Scraping: 6 Providers Compared

If you only compare price per GB, you will pick the wrong residential proxy provider. Bandwidth is the easiest number to shop on and the least predictive of whether your scraper works on the target you actually care about. This guide ranks six residential proxy providers on the four things that decide success on protected sites — pool size and freshness, sourcing transparency, session persistence, and geo-targeting granularity — with pricing verified in July 2026.

Key Takeaways

• Sticky session length is the single most under-checked spec. Oxylabs caps sticky sessions at 24 hours, IPRoyal at 7 days. If your scrape involves login, cart state, or pagination behind a session cookie, a 10-minute cap will silently break it.
• Pool size matters less than pool size in your target country. Bright Data publishes 400M+ IPs across 195 countries but only 3.9M in the US; Oxylabs publishes 175M+ with 10.3M in the US. For US-only scraping, the smaller network is the deeper one.
• Ethical sourcing is now a procurement question, not a marketing one. Ask for the opt-in mechanism, an audit, and a KYC policy. Bright Data, Decodo (ISO/IEC 27001:2022), and SOAX publish all three; some providers publish none.
• Residential proxies are billed per gigabyte, so rendering JavaScript can cost 10-20x more than fetching raw HTML for the same page. Turn rendering off before you shop for a cheaper per-GB rate.
• Entry pricing spans 5x. Webshare starts at $3.50/GB for 1GB, Oxylabs at $6/GB for 5GB, IPRoyal at $7/GB pay-as-you-go. Volume rates converge around $2.50-$3.50/GB.
• Start on datacenter IPs. Only move a target to residential once you see 403s or CAPTCHAs that survive user agent rotation. On our own published credit table, a residential request costs 10x a datacenter one.

What Actually Separates Residential Proxy Providers?

Residential proxies route requests through IP addresses that ISPs assigned to home connections, so anti-bot systems see an ordinary consumer IP instead of a known datacenter range. Every provider on this list does that. The differences are elsewhere.

Pool depth in your geography. A "400M IPs worldwide" headline tells you nothing if you scrape German retail and the provider has 200k German IPs. Providers increasingly publish per-country counts — read those, not the global number.

Sourcing transparency. Residential IPs come from real people's connections, which means the provider had to get them somehow: an SDK bundled into a free app, a paid opt-in panel, or an ISP partnership. If the provider can't tell you which, you're inheriting their compliance risk. This became a real buying criterion after the industry's proxyware disclosures, and it's the reason enterprise procurement now asks for audits.

Session persistence. "Rotating" and "sticky" are the two modes. Rotating gives you a new IP per request, which is right for independent page fetches. Sticky pins one IP for a set duration, which is required the moment your scrape has state — a search that paginates, a cart, an authenticated session. Providers cap sticky duration very differently.

Geo granularity. Country-level targeting is table stakes. City, ZIP, and ASN targeting are not, and they're what you need for localized pricing, price monitoring across regions, or SERP monitoring by metro.

Which Residential Proxy Provider Should You Use?

Disclosure: some provider links on this page are affiliate links, and we may earn a commission if you sign up through them. This never affects which providers we include or how we rank them — pricing and specs come from each provider's own public pages.

Pricing and pool figures taken from each provider's own residential proxy page, July 2026. Promotional rates are marked — check the current page before you budget.

Bright Data — the deepest network, and the clearest paper trail

Bright Data publishes 400M+ monthly residential IPs across 195 countries and is unusually explicit about where they come from: app owners embed an SDK, users opt in and are compensated, and the company states every IP opts in with independent auditing. That documentation is the reason it clears enterprise procurement.

Volume pricing runs $3.50/GB at $499/month (141GB), $3.00/GB at $999/month, and $2.50/GB at $1,999/month, with pay-as-you-go at $4/GB under a 50%-off promotion against an $8 list rate. The tradeoff is complexity — zones, a proxy manager, and a configuration surface that is overkill if you just need HTML. We keep a fuller feature-by-feature breakdown on our Bright Data alternative page.

Pick it when: your targets are the hardest tier, you need many countries, or you need a sourcing audit to sign off.

Oxylabs — long sticky sessions and deep US coverage

175M+ IPs across 195+ countries, with 10.3M in the US — more than double Bright Data's published US count despite the smaller global pool. Sticky sessions hold the same IP for up to 24 hours, which covers most stateful scrapes without a custom session manager.

Pricing starts at $6/GB (5GB for $30/month), drops to $5/GB at 20GB, $4/GB at 125GB, and $2.50/GB at 1TB. The product page doesn't state a sourcing or audit position, so ask for it in writing if that matters to you. See our Oxylabs alternative page for how it compares to an API-first approach.

Pick it when: you scrape US targets at volume and need sessions that survive a full working day.

Decodo (formerly Smartproxy) — the best geo granularity per dollar

Decodo publishes 115M+ ethically sourced IPs across 195+ locations, backed by ISO/IEC 27001:2022 certification. The differentiator is targeting: continent, country, state, city, ZIP code, and ASN are included on every plan at no extra cost, which most competitors either gate behind higher tiers or don't offer at all.

Rates are $3.75/GB at 3GB ($11.25), $3.50/GB at 10GB, $3.00/GB at 50GB, and $2.75/GB at 100GB, with pay-as-you-go at $4/GB. Sticky sessions are configurable from minutes to days.

Pick it when: you need ZIP- or ASN-level targeting and don't want to buy an enterprise plan to get it.

IPRoyal — sessions up to 7 days, and traffic that doesn't expire

The smallest pool here at 64M+ IPs across 195+ countries, but two specs stand out. Sticky sessions run up to 7 days — the longest published cap on this list — and purchased traffic never expires, so bursty workloads don't forfeit unused GB at the end of the month. Pay-as-you-go starts at $7/GB for 1GB and falls to $1.75/GB at volume on a subscription.

Pick it when: your scrape holds one identity for days, or your usage is lumpy enough that monthly expiry is the real cost.

SOAX — try it for $1.99 before committing

155M+ IPs across 195+ locations with region, city, and ASN targeting, a stated ethical-sourcing position, and a published KYC/KYB policy. Per-GB pricing isn't listed on the product page, but a 3-day 400MB trial for $1.99 is — which is the cheapest honest way to test whether a network actually beats your target before you commit budget.

Pick it when: you want to benchmark success rate on your own URLs first, or you need a provider with a documented customer-vetting policy.

Webshare — lowest entry cost

80M+ IPs across 195 countries at $3.50/GB for 1GB under a 50% promotion (list $7/GB), scaling to $1.40/GB at 3,000GB. Sourcing is described only as "carefully selected partners," and sticky session limits aren't published. If price per GB is your binding constraint, start with our cheapest residential proxies comparison, which ranks the budget tier properly.

Pick it when: you're testing feasibility and want the smallest possible first purchase.

How Do You Use Sticky Sessions Correctly?

Nearly every provider encodes the session ID in the proxy username. The token differs (session-, sessid-, _session-), so check your provider's docs — but the shape is the same:

import requests

USER, PASS = "your-username", "your-password"
GATEWAY = "gate.example-proxy.com:7000"

def session_proxy(session_id: str, country: str = "us") -> dict:
    # One pinned IP per session_id, for as long as the provider's cap allows.
    auth = f"{USER}-country-{country}-session-{session_id}:{PASS}"
    url = f"http://{auth}@{GATEWAY}"
    return {"http": url, "https": url}

# All three requests share one IP — required when the site tracks state.
s = requests.Session()
proxies = session_proxy("cart-42")
for path in ["/search?q=laptop", "/product/123", "/cart"]:
    r = s.get(f"https://example.com{path}", proxies=proxies, timeout=30)
    print(path, r.status_code)

For independent page fetches, do the opposite — a fresh session ID per request — and add retries that treat proxy failures as transient:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

retry = Retry(
    total=3,
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "HEAD", "OPTIONS"],  # method_whitelist was removed in urllib3 2.x
    backoff_factor=1,
)
session = requests.Session()
session.mount("https://", HTTPAdapter(max_retries=retry))

One cost note that catches people out: residential proxies bill by bandwidth, and a JavaScript-rendered page pulls images, fonts, and scripts that a raw HTML fetch never touches. If you can parse the data out of the initial HTML, do — see the headless browser guide for when rendering is genuinely required.

Can You Skip Proxy Management Entirely?

If what you want is the page, not a proxy network, an API that owns the proxy layer removes the whole evaluation. WebScraping.AI exposes residential IPs as a parameter:

import requests

resp = requests.get(
    "https://api.webscraping.ai/html",
    params={
        "api_key": "YOUR_API_KEY",
        "url": "https://example.com/product/123",
        "proxy": "residential",   # datacenter (default) | residential | stealth
        "country": "de",
        "js": "false",            # raw HTML — cheaper, and enough for most pages
    },
    timeout=60,
)
print(resp.status_code, len(resp.text))

Credits are published rather than negotiated: datacenter costs 1 credit without JS rendering and 5 with it, residential costs 10 and 25, and stealth costs 50 either way. Failed requests are free, so a blocked target doesn't bill you. Plans start at $29/month for 250,000 credits, and the free tier gives 2,000 credits per month with no card. Because billing is per request rather than per gigabyte, a heavy page costs the same as a light one — the opposite of the per-GB model above, and usually the better deal when your pages are large.

The rest of the API is documented in the docs, and if you're deciding between proxy types in the first place, our types of proxies guide covers the taxonomy and our datacenter provider comparison covers the cheaper tier you should try first.

How Do You Evaluate a Provider Before You Buy?

Run the same test on every shortlisted network, on your own targets — not on httpbin.org:

1. Buy the smallest increment. 1GB or a trial. Never commit to a monthly plan on a vendor's published success rate.
2. Fire 200 requests at your hardest real target with a fresh session per request, and count non-200 responses. This is the only success-rate number that means anything.
3. Repeat with a sticky session across a 3-5 page flow, and confirm the IP actually holds.
4. Check the per-country pool, not the global one, for every geography you need.
5. Measure bytes per page, then multiply by your monthly page count. That is your real bill, and it's usually higher than the estimate you made from the per-GB rate.
6. Ask for the sourcing and KYC documentation before you scale. If it doesn't exist, that's your answer.

Whichever provider you choose, keep the legal side deliberate rather than assumed — scraping public data is generally defensible, but the specifics matter, and our guide on whether web scraping is legal covers where the lines actually sit.

Want to skip the evaluation? Start with 2,000 free credits — no credit card — and switch a target to proxy=residential with one parameter.