Skip to content
proxycosts
Prices checked up to Nov 17, 2026

Choose and configure a residential proxy

Write down five settings your job needs: a new IP for each request or the same one for a while, the country, HTTP or SOCKS5, a login by password or by your own IP address, and how many connections run at once. Price only the plans whose pages show them, at a month of your traffic, then run the check below before a long job: it tells a proxy that fails from a site that blocks you. A low rate that needs 100,000 GB is not a cheap plan for 50 GB.

For 50 GB that is Geonode at $34.65 (Residential monthly subscription, monthly), the cheapest of 59 plans that cover it. Price checked Nov 17, 2026. Price your own amount and settings →

Priced, checked up to Nov 17, 2026:

Every billing type competes; free plans are left out. Change the amount on each comparison.

Buying guide · The comparison uses prices checked up to Nov 17, 2026; every figure in the text keeps the date it was checked.

Your settings and the bill

This opens on an example to type over: a scraper of US pages using 50 GB a month, a new IP for each request.

Only a published yes counts: a plan is left out when its page does not say it rotates, holds a session that long, offers country or city targeting, speaks SOCKS5 or allows that many connections. Traffic is priced every month for a year, the cheapest way each plan allows.

53 plans show every setting and cover 50 GB a month. The cheapest is Geonode at $34.65 a month, $0.69 per GB you use.

  1. 1GeonodeResidential monthly subscription
    A month$34.65Monthly$0.69 per GB you use
    What you get
    50 GB needed50 GB included
    Rolls over while subscribed · 0 GB unused
    The catchRenews monthly; unused traffic rolls over while you keep the subscription.
  2. 2QuanticDataResidential Basic, 360-day bundles
    A month$45Pay once$0.90 per GB you use
    What you get
    50 GB a month needed50 GB a month included
    Traffic expires after 360 days · 0 GB a month unused
    The catchYou pay $450 up front for 10 months of traffic; whatever is left after 360 days expires.
  3. 3EvomiCore Residential Monthly
    A month$49Monthly$0.98 per GB you use
    What you get
    50 GB needed100 GB included
    Traffic expires after 30 days · 50 GB unused
    The catchYou buy 100 GB to use 50 GB; the unused 50 GB expires after 30 days.
  4. 49ProxyTraffic-based residential, 180-day expiry
    A month$50Pay once$1 per GB you use
    What you get
    50 GB a month needed50 GB a month included
    Traffic expires after 180 days · 0 GB a month unused
    The catchYou pay $200 up front for 4 months of traffic; whatever is left after 180 days expires.
  5. 5DataImpulseResidential Standard PAYG
    A month$50Pay once$1 per GB you use
    What you get
    50 GB needed50 GB included
    Traffic never expires · 0 GB unused
    The catchPay once; the traffic never expires, so nothing you buy is lost.

6 more plans cover 50 GB a month but their pages do not show every setting you chose. Only a published yes counts here: ask a provider before you rule its plan out.

Every plan for these settings, with more filters →

Your setup in Python

Your provider's dashboard gives the address: a host and port, with the username and password unless you allowlist this computer. The country and the session are often set in the username; copy it as the dashboard writes it.

1. Set the address (macOS or Linux terminal)

export PROXY_URL="http://USERNAME:[email protected]:7000"

In Windows PowerShell: $env:PROXY_URL = "http://USERNAME:[email protected]:7000"

2. Save this as check_proxy.py and run it

# Check a residential proxy before a long run. Python 3 with Requests.
# Install Requests once: python3 -m pip install requests
# Set PROXY_URL to your proxy's address first (above), then run: python3 check_proxy.py
import os
import requests

PROXY = os.environ["PROXY_URL"]
proxies = {"http": PROXY, "https": PROXY}
TIMEOUT = (10, 30)  # seconds to connect, seconds to wait for the answer
COUNTRY = "US"  # the country set in your dashboard
SAME_IP = False  # rotating: a new IP for each request
PAGE = "https://example.com/"  # a page your job needs
MUST_HAVE = "Example Domain"  # words the real page always has
PER_GB = 0.69  # dollars per GB used on your plan
BLOCK_WORDS = ("captcha", "verify you are human", "access denied", "unusual traffic")


def fetch(url, must_have=""):
    """Who failed: the proxy, the site, or nobody. Returns (verdict, response or None)."""
    try:
        r = requests.get(url, proxies=proxies, timeout=TIMEOUT)
    except requests.exceptions.ProxyError as error:
        if "407" in str(error):
            return "proxy: login refused (407); check the username and password", None
        if any(code in str(error) for code in ("502", "503", "504")):
            return "proxy: it could not reach the site; try again or another country", None
        return "proxy: no connection; check the host and port", None
    except requests.exceptions.Timeout:
        return "timeout: no answer in time; try again before you blame the site", None
    except requests.exceptions.ConnectionError:
        return "connection failed on the way; try again", None
    if r.status_code == 407:
        return "proxy: login refused (407); check the username and password", None
    if r.status_code in (403, 429):
        return f"site: refused this address ({r.status_code}); slow down or change IP", None
    if r.status_code >= 400:
        return f"site or proxy: error {r.status_code}; try again", None
    text = r.text.lower()
    if must_have.lower() not in text:
        if any(word in text for word in BLOCK_WORDS):
            return "site: a block page sent as a success (200)", None
        return "site: a success (200), but not the page you wanted", None
    return "ok: the real page", r


def check(step, url, must_have=""):
    verdict, r = fetch(url, must_have)
    if r is None:
        raise SystemExit(f"{step}. {verdict}")
    return r


mine = requests.get("https://api.ipify.org", timeout=TIMEOUT).text
print("1. Your own address:", mine)
seen = check(1, "https://api.ipify.org").text
print("   The site sees:", seen, "| ok" if seen != mine else "| the same: the proxy is not in use, or runs on this computer")

where = check(2, "https://ipinfo.io/country").text.strip()
print("2. Country:", where, "| ok" if COUNTRY in (None, where) else f"| expected {COUNTRY}")

ips = [check(3, "https://api.ipify.org").text for _ in range(3)]
held = len(set(ips)) == 1
print("3. Three requests:", ", ".join(ips), "| ok" if held == SAME_IP else "| not as sold: ask the provider")

verdict, r = fetch(PAGE, MUST_HAVE)
print("4.", verdict)
if r is not None:
    # The bytes as sent, compressed where the site compresses, which is what a plan bills; the page itself if Requests cannot tell.
    size = r.raw.tell() or int(r.headers.get("Content-Length") or 0) or len(r.content)
    gb = size * 1000 / 1e9
    cost = f", ${gb * PER_GB:,.2f}" if PER_GB else ""
    print(f"   {size / 1000:,.1f} KB as sent; 1,000 pages like it use about {gb:,.3f} GB{cost}")

Put a page your job needs in PAGE and words that page always shows in MUST_HAVE. The check uses a few KB of traffic. PER_GB is the cheapest plan's price above, so the last line prices 1,000 pages like yours.

On this page

The five settings, and how to choose each

Residential IPs cost more per GB than datacenter IPs, and earn it on sites that refuse datacenter addresses; if yours does not, start with residential vs datacenter proxies.

  1. A new IP for each request, or the same one for a while. Rotating suits jobs where each request stands alone, such as search results, product pages and prices. A sticky session keeps one IP for a set time, for anything that logs in, fills a cart or walks through several pages: a site that sees one visitor change address halfway often asks again or blocks. Choose the shortest session that covers one visit, since a long one sends many requests from one address. How each works: sticky sessions and rotation.
  2. The country first, a city only if the page changes by city. Nearly every residential provider we track includes country targeting in the price, and most include cities; where a provider charges more for a city, the bill above prices it in. Choose a country when the site shows prices or results by country. What targeting adds: city and ASN targeting costs.
  3. HTTP unless your tool needs SOCKS5. Python Requests, curl, browsers and most scraping tools take an HTTP proxy, and it carries HTTPS pages too. SOCKS5 is for a tool that only speaks it, or for traffic that is not web pages; in Python, write it socks5h:// so the proxy looks up site names, not your own network. Not every plan offers it: HTTP vs SOCKS5.
  4. A username and password, or your own IP address. A password works from any computer, including a laptop whose address changes. An allowlist lets in requests from your server’s fixed address with no password, which suits tools that cannot send one, such as Chrome driven by Selenium. The dashboard says which a plan offers, and some cap how many addresses you may add: password vs IP allowlist.
  5. How many connections at once. Count the requests your job runs side by side at its peak. Plans state a cap on connections or threads, or say there is none; a plan whose page says nothing has an unknown cap, so ask before you buy. See concurrency limits.

Blocked page or real failure

The check above sorts every outcome by who caused it, because the fix depends on it: a refused login is yours to correct, a gateway error is the provider’s, and a block page means the site saw through the request.

What you see Who sent it What to do
407 Proxy Authentication Required The proxy refused the login Check the username and password, or add your address to the allowlist: 407
No connection to the proxy Nobody answered at that host and port Copy the host and port from the dashboard again
502, 503 or 504 from the proxy The proxy’s exit could not reach the site Try again; if it repeats, another country: 504
A timeout Either side Try once more, after a pause, before you blame the site
403 Forbidden or 429 Too Many Requests The site refused this address or this pace Slow down and change IP: 403, 429
200 with a captcha or “verify you are human” The site, with a block page sent as success Count it as failed: 200 OK but blocked
200 without the words your page always has The site: an empty page, or another country’s Check the country, and whether the page needs a browser to fill in

A block page is traffic too: on a plan billed by the GB it is paid for, unless the provider’s terms say failed requests are free. We ran the check on Oct 29, 2026, with Python 3.12.3, Requests 2.32.5 and urllib3 2.0.7, against test proxies on our own machine (one with a login, one allowlisted, one SOCKS5 through PySocks 1.7.1) and test pages answering 200, 403, 429, 500 and a block page: each case printed the verdict in this table. A test proxy on your own computer shows your own address in step 1 and that computer’s country in step 2, as ours did; a provider’s exit shows its own. Every error Requests raises, and retries that wait: the Python Requests setup guide.

How to choose a residential plan

  1. Estimate your traffic as a range. Take the upper end of a normal month; how much bandwidth does web scraping use helps if you count in pages.
  2. Compare checkouts at that amount. The cheapest plan is the lowest total that covers it, whatever its rate per GB. A big package’s rate cannot be applied to a smaller order.
  3. Match the traffic’s lifetime to your schedule. If your use is uneven, prefer traffic that never expires or rolls over while you stay subscribed; a 30-day package used for 40% of its traffic costs two and a half times its rate per GB used. See traffic expiry.
  4. Check that one balance covers all your work. If several projects, team members or proxy types share the traffic, the plan must say the balance is shared; see bandwidth pooling.
  5. Check the five settings above on the plan’s own page. The bill above counts only what a page says; a setting it does not mention is a question for the provider before you pay.
  6. Then test it. Buy the smallest package on the site you need, and run the check inside the trial or refund window, before you commit to a large one: we compare published prices, not success rates.

What the range of rates hides

The four amounts priced near the top of this page show the median price per GB falling as the amount grows, and the cheapest provider changing with it. Both ends of the market are real and both are misleading on their own: the lowest rates belong to packages of thousands of gigabytes with checkouts to match, and the highest to single gigabytes bought without a subscription. Calling either “the residential price” leaves out the purchase that sets it.

Expiry changes the value of the same amount

Two plans can sell the same gigabytes at different prices because one lets them wait. Where one provider sells both, the gap is the price of time; is non-expiring bandwidth worth it? works out when it pays. A monthly bill does not by itself mean traffic expires monthly, and a plan that does not say is not a plan whose traffic never expires.

Shared balances and several proxy types

Some providers sell one balance that pays for residential and mobile traffic alike, or for several sub-users; others keep each plan’s traffic to that plan. With one balance, a quiet project’s traffic is used by a busy one instead of expiring. Credits, gigabytes and their expiry rules still differ between providers, so compare each in its own terms.

What this guide cannot tell you

Published prices say what you pay, not how well a network works on your target. They cannot prove pool quality, speed or success rate, and they cannot turn a plan sold by IP, port or time into a price per GB without guessing your traffic. Those plans are compared in their own units: per IP versus per GB explains which fits your job. The check above is how you find out on your own target, for the price of a few KB.

On this page