Best Datacenter Proxies for Web Scraping: 6 Providers Compared

If you want the short answer: Webshare is the cheapest way to start (10 free proxies, then $2.99/month for 100 shared IPs), Decodo and Oxylabs are the best per-GB rotating pools for scraping, Bright Data wins on geographic reach (98 countries), and IPRoyal and Rayobyte are the value picks for dedicated static IPs.

The harder question is which pricing model you should be buying at all. Datacenter proxies are sold three incompatible ways — per IP per month, per GB of traffic, and per request — and the provider that looks cheapest under one model is often the most expensive under another. This guide compares six providers on all three, gives you the connection endpoint for each (the part every comparison post leaves out), and shows you how to benchmark them against your own target before you commit.

Every price below was checked against the provider's own pricing page in July 2026.

Key Takeaways

• Per-GB beats per-IP once your traffic-per-IP drops below roughly 20 GB/month. A $1.00/IP dedicated proxy is only cheap if you actually push volume through it; at 5 GB/month you're paying $0.20/GB effective, versus Rayobyte's $0.23/GB or Decodo's $0.45/GB with no idle IPs.
• Cheapest real entry points, July 2026: Webshare free tier (10 proxies, 1 GB), Decodo 10 GB for $6, Oxylabs 20 GB for $11.80 or 3 dedicated IPs for $6.75, Webshare 100 shared IPs for $2.99.
• Shared datacenter IPs are already burned on the big targets. Amazon, Cloudflare-fronted sites, and Google have had those subnets flagged for years. Shared pools are for long-tail sites and internal APIs; dedicated IPs or residential proxies are for the rest.
• The switching signal is a 403/429 rate above ~5%, not a gut feeling. Below that, stay on datacenter and save 10-25x on cost.
• Endpoints changed in 2025-26. Decodo's gateway is dc.decodo.com:10000 (the Smartproxy-branded host predates the rebrand) and Bright Data's is brd.superproxy.io:44445, not the old zproxy.lum-superproxy.io:22225 you'll find in older tutorials.
• IPRoyal and Rayobyte static plans don't give you a gateway at all — you get a list of ip:port pairs and rotate them yourself.

What are datacenter proxies, and when should you use them?

Datacenter proxies are IPs owned by hosting companies rather than consumer ISPs. Because they live on server hardware in a rack, they're fast (typically sub-second added latency, gigabit uplinks) and cheap. Because their whole /24 subnet is registered to an ASN like Hetzner or DigitalOcean, an anti-bot system can identify and block them in one rule.

That trade-off gives you a clean decision rule:

• Use datacenter proxies for sites with no serious bot defence, internal or partner APIs, high-volume crawls where you'd bankrupt yourself on residential bandwidth, and anything where you control or have permission to hit the target.
• Move to residential or stealth the moment your block rate on a target passes ~5%, or you see CAPTCHAs and JS challenges instead of HTML.

For a full breakdown of the other proxy categories — residential, ISP, mobile — see types of proxies for web scraping.

Datacenter proxy providers compared

Prices verified July 2026 from each provider's public pricing page. "Entry cost" is the cheapest real purchase, not a promo rate.

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.

Two things fall out of that table immediately. Rayobyte's $0.23/GB rotating tier is the lowest published per-GB rate here, roughly half of Decodo's entry rate and a third of Bright Data's pay-as-you-go. And Oxylabs quotes $0.44/GB but bills at $0.59/GB unless you commit to volume, which is the kind of gap that only shows up on the invoice.

Webshare — cheapest place to start

Webshare's shared datacenter pricing is straight per-proxy-per-month with volume discounts: 100 proxies at $0.0299 each is $2.99/month, scaling to $0.0179/proxy ($1,794) at 100,000 proxies. Dedicated datacenter IPs are $0.77 and private ones $0.43. The free tier — 10 proxies and 1 GB/month, no card — is the only genuinely free datacenter offer in this list, which makes it the right place to sanity-check your scraper before you spend anything.

Endpoint: p.webshare.io:80 (also 1080, 3128, or any port 9999-29999). Country and session control are appended to the username: myuser-us-rotate.

Decodo (formerly Smartproxy) — best rotating pool for scraping

Decodo sells the same pool two ways. Pay-per-GB starts at $0.60/GB for 10 GB ($6) and drops to $0.45/GB at 1 TB ($450). Pay-per-IP starts at $0.035/IP for 100 IPs and falls to $0.02/IP at 15,000. The shared pool is 100K+ rotating and static IPs across 14 countries, plus a US-only dedicated pool of 400K+. There's a 3-day, 100 MB trial and a 14-day money-back window.

Endpoint: dc.decodo.com:10000 rotates the IP on every request; ports 10001-63000 hold a static IP. If you've been following an older tutorial using the Smartproxy-branded hostname, dc.decodo.com is the currently documented one.

import requests

proxy = "http://USERNAME:PASSWORD@dc.decodo.com:10000"
r = requests.get(
    "https://ip.decodo.com/json",
    proxies={"http": proxy, "https": proxy},
    timeout=15,
)
print(r.json())

Oxylabs — widest dedicated coverage

Oxylabs splits datacenter proxies into three products. Dedicated pay-per-IP starts at $1.20/IP with a 3-IP / $6.75 minimum, backed by 1.9M+ IPs across 188 countries. Shared pay-per-IP starts at $0.70/IP (10 IPs, $12/month) with a maximum of three users per IP — a meaningful guarantee, since most "shared" pools don't cap concurrency at all. Shared pay-per-GB starts at $0.44/GB but bills at $0.59/GB at the 20 GB / $11.80 entry tier. Five free IPs, no card.

Endpoints: dc.oxylabs.io:8000 (shared) and ddc.oxylabs.io:8000 (dedicated) rotate; ports 8001 and up are static. Country targeting goes in the username: user-USERNAME-country-US.

curl -x dc.oxylabs.io:8000 -U "user-USERNAME:PASSWORD" https://ip.oxylabs.io/location

Bright Data — the geographic reach option

Bright Data's datacenter network is 1.3M+ IPs across 98 countries, with over a million in the US alone. Shared IPs run $1.40 each at 10 IPs down to $0.90 at 1,000; dedicated run $2.20 down to $1.30. Bandwidth plans go from $0.60/GB pay-as-you-go to $0.42/GB on a 5 TB commitment. It's the most expensive entry point per IP here and the platform carries real onboarding overhead (zones, KYC on some targets), so it earns its place on coverage and ASN-level targeting rather than price. If you're evaluating it primarily as a scraping API rather than a raw proxy pool, our Bright Data alternative page has the side-by-side.

Endpoint: brd.superproxy.io:44445, authenticated with brd-customer-<id>-zone-<zone>:<password>.

IPRoyal — dedicated IPs with generous traffic

IPRoyal sells dedicated datacenter IPs on term pricing: $1.57/proxy for 30 days, $1.48 for 60, $1.39 for 90. Each IP includes 100 GB of traffic per cycle, pooled across the order — so a 10-IP order gives you 1,000 GB total. That pooling is what makes IPRoyal cheap for uneven workloads: you're not stranded with unused allowance on idle IPs. Coverage is 60+ locations with 160,134 US IPs.

There's no rotating gateway. You get a formatted proxy list of ip:port pairs (HTTP and SOCKS5 on adjacent ports, e.g. 45.12.106.20:12323 and :12324) and you rotate them in your own code — see the rotation snippet below.

Rayobyte — lowest per-GB rate

Rayobyte's rotating datacenter proxies start at $0.23/GB and static datacenter IPs at $1.00/IP, against a network of 400K+ static IPs. That per-GB rate is the lowest published figure in this comparison. Rayobyte is also one of the few providers that is upfront about being a wholesale supplier to other scraping APIs, which is a decent proxy for pool quality.

What endpoint and port does each provider use?

This is the detail that costs people an afternoon, because provider hostnames have churned and most tutorials are stale. Verified against each provider's own documentation, July 2026:

Two patterns, and they change how you write your client:

Gateway providers (Webshare, Decodo, Oxylabs, Bright Data) give you one hostname. Rotation happens server-side, so your code points at a single proxy URL forever and the provider hands you a different exit IP per request. Simplest to integrate.

List providers (IPRoyal, Rayobyte static) hand you N ip:port pairs. You own the rotation:

import itertools
import requests

PROXIES = [
    "http://user:pass@45.12.106.20:12323",
    "http://user:pass@45.12.106.21:12323",
    "http://user:pass@45.12.106.22:12323",
]

pool = itertools.cycle(PROXIES)

def fetch(url):
    proxy = next(pool)
    return requests.get(
        url,
        proxies={"http": proxy, "https": proxy},
        timeout=15,
    )

Round-robin is the right default. Random selection clusters requests onto the same IP by chance, which is exactly the pattern rate limiters look for. Pair rotation with user agent rotation — a rotating IP paired with one static, obviously-scripted User-Agent fingerprints just as well as no rotation at all.

How do I test datacenter proxies before buying?

Published benchmarks are close to useless, because "success rate" means nothing without naming the target. A pool that scores 99% against httpbin.org can score 0% against the e-commerce site you actually care about. Every provider here has a free trial or a sub-$10 entry tier — use it, and measure against your real target.

import statistics
import time
import requests

def benchmark(proxy_url, target, n=50):
    session = requests.Session()
    session.proxies = {"http": proxy_url, "https": proxy_url}
    latencies, blocked, errors = [], 0, 0

    for _ in range(n):
        start = time.perf_counter()
        try:
            r = session.get(target, timeout=20)
        except requests.RequestException:
            errors += 1
            continue
        elapsed = time.perf_counter() - start

        if r.status_code in (403, 429) or r.status_code >= 500:
            blocked += 1
        else:
            latencies.append(elapsed)

    ok = len(latencies)
    return {
        "success_rate": ok / n,
        "block_rate": blocked / n,
        "error_rate": errors / n,
        "median_latency": statistics.median(latencies) if ok else None,
        "p95_latency": (
            statistics.quantiles(latencies, n=20)[-1] if ok >= 20 else None
        ),
    }

print(benchmark(
    "http://USERNAME:PASSWORD@dc.decodo.com:10000",
    "https://your-real-target.example/product/12345",
))

Read the three rates separately. A high block rate means the pool is burned on your target and no amount of retrying fixes it — go residential. A high error rate with a low block rate means the provider's infrastructure is flaky. And watch p95 latency, not the median: a pool with a 400 ms median and a 12-second p95 will destroy a concurrent crawler's throughput even though its average looks fine.

Run the same script against two or three trials on the same target, same hour of day. That comparison is worth more than any published leaderboard.

Shared, dedicated, rotating, or static — which do I need?

Four terms, two independent axes, and providers use them inconsistently.

Shared vs dedicated is about who else uses the IP. Shared is 5-20x cheaper and fine for low-value targets; dedicated is the only option when the target tracks per-IP reputation or you need a stable identity across a session. Oxylabs capping shared IPs at three concurrent users is the exception worth noting — most shared pools make no such promise.

Rotating vs static is about whether the IP changes between requests. Rotate for breadth (crawling many URLs on one site, price monitoring across a catalog). Stay static when the target sets a session cookie or ties auth to an IP; switching IPs mid-session gets you logged out or challenged.

The common mistake is buying dedicated static IPs for a job that wants rotation. If you're fetching 100,000 product pages, 20 dedicated IPs will get all 20 rate-limited; a rotating gateway spreads the same load across thousands.

Also worth saying plainly: free proxy lists are not a cheaper version of this. They're unauthenticated, shared with everyone, frequently logging, and mostly dead. We keep a survey of free proxy lists and what they're actually good for (testing, and not much else).

Skipping proxy management entirely

The alternative to buying a pool is buying requests. A scraping API bundles the proxy, the rotation, the retry logic, and optionally a headless browser behind one HTTP call — which is usually the right trade when proxy plumbing isn't the thing you want to be maintaining.

With WebScraping.AI, datacenter proxies are the default and cost 1 credit per request without JavaScript rendering, 5 with it:

import requests

r = requests.get(
    "https://api.webscraping.ai/html",
    params={
        "api_key": "YOUR_API_KEY",
        "url": "https://example.com/products",
        "proxy": "datacenter",   # default; "residential" or "stealth" when blocked
        "js": "false",           # 1 credit instead of 5
        "country": "us",
    },
    timeout=60,
)
r.raise_for_status()
print(r.text[:500])

Switching proxy tiers is a one-word change rather than a new contract — useful precisely because you often can't tell in advance which targets need residential. Residential costs 10 credits (25 with JS) and stealth 50, so the escalation is explicit and priced up front. Failed requests are free, which matters when you're probing an unfamiliar target and expect to burn some attempts.

If you want the page parsed rather than raw, AI extraction adds 5 credits and skips the selector maintenance:

r = requests.get(
    "https://api.webscraping.ai/ai/fields",
    params={
        "api_key": "YOUR_API_KEY",
        "url": "https://example.com/products/12345",
        "fields[title]": "Product title",
        "fields[price]": "Current price in USD",
        "fields[in_stock]": "Is the product in stock, true or false",
    },
    timeout=60,
)
print(r.json())

Plans run $29/month for 250,000 credits, $99 for 1M, and $249 for 3M, with 2,000 credits/month free and no card required. Full parameter reference is in the docs.

One caveat on all of the above, whichever route you take: proxies change where your request comes from, not whether you're allowed to make it. Rate limits, terms of service, and the legal picture still apply — see is web scraping legal for the non-hand-wavy version.

Which datacenter proxy provider should I choose?

• Testing an idea, spending nothing: Webshare's free 10 proxies, then $2.99/month.
• High-volume crawling of long-tail sites: Rayobyte at $0.23/GB or Decodo at $0.45-0.60/GB. Buy per GB, not per IP.
• Need a specific country or ASN: Bright Data (98 countries) or Oxylabs dedicated (188).
• Stable identity per target, uneven traffic: IPRoyal — 100 GB per IP, pooled across the order.
• You'd rather not run proxy infrastructure: a scraping API, where the proxy tier is a request parameter.

If you're still deciding between proxy categories rather than providers, start with the proxy provider decision guide; if datacenter IPs are already getting blocked on your target, go straight to residential proxies.

Try it without buying a proxy pool. WebScraping.AI gives you 2,000 credits a month free — no credit card — with datacenter, residential, and stealth proxies behind one parameter. Get an API key.