"Cheapest residential proxy" is a search query with a hidden trap: the lowest price per GB and the lowest cost per successful request are not the same number. This post breaks down ten budget-to-mid-tier residential proxy providers from a cost-and-reliability angle, plus a script for measuring the metric that actually matters before you commit real traffic.
The trap: price per GB vs. cost per success
A proxy at $0.50/GB that fails half your requests is more expensive than one at $1.40/GB with a 98% success rate, because you're paying for retries, wasted bandwidth, and engineering time spent debugging "random" failures. Before comparing sticker prices, calculate:
real_cost = traffic_price + failed_request_overhead + retries + setup_time + support_delays
Concretely, here's a quick way to model it:
def cost_per_success(price_per_gb, success_rate, avg_response_kb=50, retry_overhead=1.3):
"""
price_per_gb: advertised price
success_rate: 0.0-1.0, measured against YOUR target site, not the vendor's claim
retry_overhead: multiplier for bandwidth wasted on failed/retried requests
"""
effective_price = price_per_gb * retry_overhead
gb_per_request = avg_response_kb / (1024 * 1024)
cost_per_request = gb_per_request * effective_price
return cost_per_request / success_rate
# Example: cheap provider, mediocre success rate
print(cost_per_success(0.50, 0.75)) # looks cheap, isn't once failures are priced in
# Example: pricier provider, high success rate
print(cost_per_success(1.40, 0.98)) # often cheaper in practice
Run this with your own measured success rate (see the test harness further down), not the vendor's advertised uptime number.
What to actually compare
Before looking at price, check whether the provider covers:
- IP pool size and quality (pool size alone tells you nothing about freshness or block rate)
- Country vs. city-level targeting
- Sticky session support (for anything stateful)
- Rotation controls (for scraping/data collection)
- HTTP(S) and SOCKS5 support
- Whether purchased traffic expires
- API/dashboard usability
- Support responsiveness when something breaks
Ten budget-to-mid-tier providers, compared
| Provider | Entry Price | Pool Size | Notable | Best For |
|---|---|---|---|---|
| Nstproxy | ~$1.40/GB (100GB tier) | 110M+ IPs, 195 locations | Multiple proxy types (residential, ISP, mobile, datacenter, IPv6) on one platform, HTTP(S)/SOCKS5, quoted 99.98% success rate | Best overall balance of price + reliability |
| Evomi | ~$0.49/GB | 54M+ IPs | Lowest advertised entry price | Cheap experimentation, test before scaling |
| DataImpulse | ~$1/GB pay-as-you-go | 90M+ IPs, 195 countries | Non-expiring traffic, no subscription | One-off projects, no recurring billing |
| PacketStream | ~$1/GB flat | — | Simple metered model | Basic low-cost access, fewer advanced controls |
| Rayobyte | Volume-discounted | 40M+ IPs | Ethical sourcing claims, unlimited threads/sessions | Scaling scraping projects over time |
| Webshare | Low entry plans | 80M+ IPs, 195 countries | Simple dashboard | Beginners, first proxy test |
| Decodo (formerly Smartproxy) | ~$2/GB at higher tiers | 115M+ IPs, 195+ locations | Polished UX, advanced geo-targeting | Usability + coverage balance |
| IPRoyal | Flexible, small-volume friendly | 32M+ IPs, 195+ countries | Non-expiring traffic, pay-as-you-go or subscription | Freelancers, no long-term contract |
| SOAX | ~$3.60/GB (Starter) | 155M+ IPs, 195+ countries | City/ISP-level targeting | Growing teams needing precise targeting |
| Oxylabs | ~$6/GB (5GB starter) | — | Enterprise-grade infra at a lower entry tier | Teams where failed requests cost more than the plan |
Pricing and pool-size figures are vendor-advertised as of writing — verify current numbers on each provider's pricing page before budgeting, since these change frequently.
A test harness for measuring real success rate
Don't take any provider's success-rate claim at face value. Run this against your actual target site before committing budget:
import time
import statistics
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
TARGET_URL = "https://example.com/your-real-target"
def make_request(proxy_url, session_id):
proxies = {"http": proxy_url, "https": proxy_url}
start = time.time()
try:
resp = requests.get(TARGET_URL, proxies=proxies, timeout=15)
return {
"success": resp.status_code == 200,
"captcha": "captcha" in resp.text.lower(),
"elapsed": time.time() - start,
}
except requests.exceptions.RequestException as e:
return {"success": False, "error": str(e), "elapsed": time.time() - start}
def run_batch(proxy_url_template, n=100, concurrency=10):
results = []
with ThreadPoolExecutor(max_workers=concurrency) as executor:
futures = [
executor.submit(make_request, proxy_url_template.format(session=i), i)
for i in range(n)
]
for f in as_completed(futures):
results.append(f.result())
return results
def summarize(results, price_per_gb, avg_response_kb=50):
total = len(results)
successes = [r for r in results if r.get("success")]
captchas = [r for r in results if r.get("captcha")]
latencies = [r["elapsed"] for r in results if "elapsed" in r]
success_rate = len(successes) / total
total_gb = (total * avg_response_kb) / (1024 * 1024)
total_cost = total_gb * price_per_gb
cost_per_success = total_cost / len(successes) if successes else float("inf")
print(f"Requests: {total}")
print(f"Success rate: {success_rate*100:.1f}%")
print(f"CAPTCHA rate: {len(captchas)/total*100:.1f}%")
if latencies:
print(f"Median latency: {statistics.median(latencies):.2f}s")
print(f"Cost per success: ${cost_per_success:.5f}")
# Example usage — plug in your provider's proxy URL pattern
proxy_template = "http://user-session-{session}-country-US:password@gate.provider.com:7000"
results = run_batch(proxy_template, n=100, concurrency=10)
summarize(results, price_per_gb=1.40)
Run this for each provider you're evaluating against the same target URL and traffic pattern, then compare cost_per_success — not the advertised price per GB.
Picking by use case
Small-scale ecommerce price monitoring (checking a few thousand product pages/day): a flexible mid-tier residential provider is usually the right call. Nstproxy's positioning here — real residential IPs, country-level targeting, session control, pay-per-use or package pricing — fits this without needing an enterprise contract.
SEO rank tracking across multiple cities: prioritize accurate city/region targeting over raw pool size. Nstproxy and Decodo both support this; SOAX is worth it too if targeting granularity is your top requirement and budget allows.
One-off research project with no recurring need: a simple pay-as-you-go model like DataImpulse or PacketStream avoids subscription overhead you won't use again.
Larger team with ongoing operational needs: Oxylabs, SOAX, or Rayobyte scale better here — the higher per-GB cost is offset by more mature tooling, support, and infrastructure once request volume gets serious.
Residential vs. datacenter vs. ISP vs. mobile — quick reference
| Type | Relative Cost | Trust Level | Best For |
|---|---|---|---|
| Datacenter | Lowest | Lower | Fast, low-risk scraping |
| Residential | Medium | Higher | Ecommerce, SEO, ads, research |
| Static ISP | Higher | High + stable | Long sessions, account management |
| Mobile | Highest | Very high | Mobile-first platforms, sensitive workflows |
If your target site actively blocks datacenter IPs, residential proxies are often cheaper in practice despite the higher sticker price, because your failure rate — and therefore your real cost per success — drops substantially.
Skip free residential proxies for anything real
Free proxy lists are consistently slow, already overused, frequently already blocked by major sites, and a bad idea for anything touching authenticated sessions. If budget is the constraint, a genuinely cheap paid tier (Evomi, DataImpulse, PacketStream, or Nstproxy's lower-cost residential tier) will outperform free proxies on every metric that matters, including total cost once you factor in wasted engineering time.
Bottom line
Don't shop by price-per-GB. Pull the actual numbers with the test harness above, calculate cost-per-successful-request against your real target site, and match session/rotation behavior to your workflow (rotating for scraping, sticky/static for anything stateful). Among the budget-to-mid-tier options, Nstproxy is worth testing first if you want one platform that covers residential, ISP, mobile, datacenter, and IPv6 without switching vendors as your requirements grow — but run the numbers yourself before committing volume to any provider on this list.
Top comments (0)