← Blog · · 10 min read

Residential vs. Datacenter Proxies: When to Use Each

Blue-lit data center hall with long server aisles, overhead ducts, and glossy floors

Use a residential proxy when the page you get depends on looking like an ordinary visitor: a site that serves challenge pages or thinner content to hosting-network addresses, or a page that changes by country. A datacenter proxy is enough when the site accepts traffic from servers and gives every visitor the same page. The difference is the network behind the exit IP. A datacenter proxy exits from a server in a hosting or cloud network. A residential proxy exits through a home internet connection that a consumer ISP assigned to a household.

Most teams end up using both and routing by destination. The table below is a starting point for that decision, and the rest of this guide explains the trade-offs, the cost per GB, and how to test which type a job actually needs.

Residential vs. datacenter proxies by workload

WorkloadStart withWhyCost per GB to plan for
High-volume collection from sites that serve server traffic normally (open data portals, documented public APIs)DatacenterThe exit network does not change the response, so throughput and price per request decide.Datacenter plans are usually sold per IP or per month, so cost per GB falls as volume rises.
Monitoring or testing your own sites and APIsDatacenter, or no proxyYou control the destination and can allowlist your checkers.Not worth paying per GB for.
Public pages that change by country (localized prices, availability, search results, ad placement checks)Residential with country targetingYou need an exit in that country on a consumer connection, and the result must come from the country you asked for.$1/GB on PacketStream. Pages are often small, so a GB covers many checks.
Public pages that return challenge pages, block notices, or degraded "200 OK" pages to datacenter trafficResidential, rotatingThe destination treats hosting-network traffic differently, so the datacenter results are not usable data.$1/GB. Trim images, fonts, and media to keep the bill tied to the data you keep.
Multi-step public flows that set cookies (paginated or filtered search, a results page then its detail pages)Residential, sticky sessionRelated requests should share one exit so the site sees one consistent visitor.$1/GB; sticky and rotating sessions cost the same.
Occasional, low-volume checks across many destinationsResidentialPer-GB billing with no subscription is cheap when traffic is light.$1/GB from a $50 balance that does not expire.

If you are unsure, start with the cheaper option for that destination and move it to residential only when the responses stop being valid. "Valid" means the page contains the data you expected, not that the status code was 200. The soft blocks guide covers how to check that.

What actually differs

Residential proxyDatacenter proxy
Exit IP belongs toA consumer ISP, on a household connectionA hosting, cloud, or colocation provider
How sites can classify itLooks like a home visitor at the network levelEasy to identify as server traffic from the network that owns the address
Speed and consistencyDepends on the home connection behind each exit, so it variesServers on hosting networks, so throughput is usually higher and steadier
LocationWherever the household is; choose by countryWherever the provider has servers
IP lifetimeAn exit can go offline when the household device disconnectsAddresses stay up as long as the server and plan do
Typical pricing modelPer GB of trafficPer IP or per month, often with bundled bandwidth

Two of these rows matter more than the rest in practice.

Classification is about the network, not the request. A residential exit changes which network your traffic arrives from. It does not change your request rate, headers, cookies, browser locale, or behavior. A site can still slow down or block traffic that behaves like an aggressive bot, whichever network it comes from. Residential exits make sense when the network type is the reason your requests fail; they do not fix a crawler that ignores rate limits. See can a residential proxy be detected for the other signals sites use.

Residential exits are real devices. They come and go. Design for that: use rotation for independent requests, and when a workflow needs one IP, handle the case where that IP disappears (covered below).

Cost per GB

PacketStream sells residential bandwidth at $1 per GB. The minimum purchase is $50, there is no subscription, and the purchased balance does not expire. Rotating and sticky sessions use the same rate. See the pricing page for the current terms.

Because residential traffic is metered by the byte, the useful question is what one successful page costs you, not what an IP costs. As an illustration: if a page and the requests it needs transfer 500 KB in total, 1 GB covers about 2,000 pages, or roughly $0.0005 per page at $1/GB. Measure your own pages before planning a budget; the bandwidth estimation guide shows how, and where residential proxy bandwidth goes covers what to block.

Ways to keep the per-GB bill proportional to the data you keep:

  • Send only the destinations that need it through residential exits. Everything else can go direct or through the datacenter proxy you already use.
  • Prefer plain HTTP requests over a full browser when the data is in the HTML.
  • In a browser, block images, media, and fonts you do not parse.
  • Do not retry soft blocks at full speed. Each retry downloads the page again.

Route by destination in code

PacketStream's gateway is proxy.packetstream.io. Use port 31111 for the HTTPS proxy (recommended), 31113 for SOCKS5, or 31112 for plain HTTP when a client cannot use the other two. The username is your PacketStream username and the password is your auth key from the dashboard.

Check a residential exit with cURL first:

export PACKETSTREAM_USER='your_username'
export PACKETSTREAM_AUTH_KEY='your_auth_key'

curl --silent --show-error --fail-with-body \
  --proxy 'https://proxy.packetstream.io:31111' \
  --proxy-user "${PACKETSTREAM_USER}:${PACKETSTREAM_AUTH_KEY}" \
  'https://ipinfo.io'

To ask for a specific country, append _country- and an ISO two-letter code to the auth key. If no exit is available in that country, the request fails rather than falling back to another location:

curl --silent --show-error --fail-with-body \
  --proxy 'https://proxy.packetstream.io:31111' \
  --proxy-user "${PACKETSTREAM_USER}:${PACKETSTREAM_AUTH_KEY}_country-US" \
  'https://ipinfo.io'

In Python, keep the routing decision in one function so the residential share of your traffic is deliberate. This example sends listed hosts through a US residential exit and leaves everything else on your existing route:

import os
from urllib.parse import quote, urljoin, urlsplit

import requests

USER = os.environ["PACKETSTREAM_USER"]
AUTH_KEY = os.environ["PACKETSTREAM_AUTH_KEY"]

# Destinations whose responses differ for datacenter traffic or by country.
RESIDENTIAL_HOSTS = {"www.example.com"}
# Optional: your current datacenter proxy, for example http://user:pass@host:port
DATACENTER_PROXY = os.environ.get("DATACENTER_PROXY_URL")


def residential_proxy(country=None, session=None):
    password = AUTH_KEY
    if country:
        password += f"_country-{country}"
    if session:
        password += f"_session-{session}"
    url = (
        f"https://{quote(USER, safe='')}:{quote(password, safe='')}"
        "@proxy.packetstream.io:31111"
    )
    return {"http": url, "https": url}


def proxies_for(url):
    if urlsplit(url).hostname in RESIDENTIAL_HOSTS:
        return residential_proxy(country="US")
    if DATACENTER_PROXY:
        return {"http": DATACENTER_PROXY, "https": DATACENTER_PROXY}
    return {}


def fetch(url, max_redirects=5):
    # Follow redirects one hop at a time so each host gets its own route.
    # One Session keeps cookies that a redirect sets for the next hop.
    with requests.Session() as session:
        for _ in range(max_redirects + 1):
            response = session.get(url, proxies=proxies_for(url), timeout=30,
                                   allow_redirects=False)
            if not response.is_redirect:
                return response
            url = urljoin(url, response.headers["Location"])
    raise RuntimeError(f"more than {max_redirects} redirects")


response = fetch("https://www.example.com/")
response.raise_for_status()
print(response.status_code, len(response.content), "bytes")

Pass proxies on each request, as above, so environment proxy settings do not silently replace the route you chose. Requests keeps the first route when it follows a redirect on its own, so fetch follows redirects itself and picks the route again for each host. More clients, including Node.js, Go, and Playwright, are in the language integration docs.

Rotation and sticky sessions

With the plain auth key, PacketStream picks an available residential exit each time your client opens a new proxy connection. Requests sent over a connection that is already open keep its exit, so an HTTP client that reuses connections will often show the same IP for several requests. A new connection is not guaranteed to get a different IP either; the rule is a new selection per connection. How connection pooling affects rotation explains what that means for common clients.

To keep one exit for a related workflow, append _session- and a label to the auth key, for example AUTH_KEY_session-catalog42. The label keeps the same IP for as long as it opens at least one successful new connection in every 60-minute window. PacketStream never moves a session to another IP: if the household device providing it disconnects, new connections on that label fail with 502 Proxy Error (sticky session IP is offline) until the IP returns or the label expires. Start a new label and restart the workflow from a checkpoint if you cannot wait. The rotation and sticky sessions docs have the full contract.

Test which type a destination needs

Do not decide from a single request. Take a small, fixed list of public URLs from the destination and fetch each one through your datacenter route and through a residential exit, at a polite rate. For each response, check:

  • the final URL after redirects;
  • whether the content you parse (prices, result rows, the item title) is present;
  • whether many different URLs return the same body, which usually means one block page;
  • the bytes transferred, so you can price the residential run.

If the datacenter responses already contain valid data, keep that destination on datacenter. If they do not and the residential ones do, the per-GB cost buys you usable data and the routing table above tells you where to put it. Repeat the check when a site changes, because the answer is per destination and can change over time.

Frequently asked questions

Are residential proxies faster than datacenter proxies?

No. Datacenter proxies run on servers in hosting networks, so they are usually faster and more consistent. A residential exit's speed depends on the home connection behind it. Choose residential for the responses it gets, not for speed.

Why do residential proxies cost more?

Residential traffic runs over real household connections, and those households are paid for the bandwidth they share, so residential proxies are usually billed per GB. PacketStream charges $1/GB with a $50 minimum purchase, no subscription, and a balance that does not expire.

Can I use residential and datacenter proxies together?

Yes, and it is usually the cheapest setup. Route each destination to the cheapest option that returns valid data, and send only the destinations that need it through residential exits.

Is a residential proxy the same as an ISP proxy?

No. An ISP proxy is an address registered to an ISP but hosted on a server, so it is static and fast but is not a household connection. A residential proxy exits through an actual home connection. See what is a residential proxy for a comparison of residential, datacenter, ISP, and mobile proxies.

Get started

PacketStream's network is residential: rotating and sticky sessions, country targeting, and HTTPS, SOCKS5, and HTTP endpoints, all at $1/GB. Create an account, add a balance, and run the cURL check above before you move a destination over.

Previous Post Next Post