What Makes a Residential Proxy Actually "Enterprise-Grade" (A Technical Buyer's Checklist)

import time
import requests
import statistics
from concurrent.futures import ThreadPoolExecutor, as_completed

TARGET_URL = "https://example.com"  # replace with your real target
PROXY_HOST = "gate.provider.com"
PROXY_PORT = "7000"
PROXY_USER = "user-session-{}-country-US"
PROXY_PASS = "your_password"

def make_request(session_id):
    proxy_url = f"http://{PROXY_USER.format(session_id)}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}"
    proxies = {"http": proxy_url, "https": proxy_url}
    start = time.time()
    try:
        resp = requests.get(TARGET_URL, proxies=proxies, timeout=15)
        elapsed = time.time() - start
        return {
            "session_id": session_id,
            "status": resp.status_code,
            "elapsed": elapsed,
            "success": resp.status_code == 200,
            "captcha": "captcha" in resp.text.lower(),
        }
    except requests.exceptions.RequestException as e:
        return {"session_id": session_id, "success": False, "error": str(e), "elapsed": time.time() - start}

def run_batch(n=200, concurrency=20):
    results = []
    with ThreadPoolExecutor(max_workers=concurrency) as executor:
        futures = [executor.submit(make_request, i) for i in range(n)]
        for f in as_completed(futures):
            results.append(f.result())
    return results

def summarize(results):
    successes = [r for r in results if r.get("success")]
    failures = [r for r in results if not r.get("success")]
    captchas = [r for r in results if r.get("captcha")]
    latencies = [r["elapsed"] for r in results if "elapsed" in r]

    print(f"Total requests:     {len(results)}")
    print(f"Success rate:       {len(successes) / len(results) * 100:.1f}%")
    print(f"CAPTCHA rate:       {len(captchas) / len(results) * 100:.1f}%")
    print(f"Failure rate:       {len(failures) / len(results) * 100:.1f}%")
    if latencies:
        print(f"Median latency:     {statistics.median(latencies):.2f}s")
        print(f"P95 latency:        {sorted(latencies)[int(len(latencies)*0.95)]:.2f}s")

if __name__ == "__main__":
    results = run_batch(n=200, concurrency=20)
    summarize(results)

def cost_per_success(results, price_per_gb, avg_response_kb=50):
    successes = [r for r in results if r.get("success")]
    total_gb = (len(results) * avg_response_kb) / (1024 * 1024)
    total_cost = total_gb * price_per_gb
    if not successes:
        return float("inf")
    return total_cost / len(successes)

import uuid

def build_proxy(host, port, user_base, password, country=None, sticky=False, session_id=None):
    """
    sticky=True  -> reuse session_id across calls (same exit IP)
    sticky=False -> new session_id per call (new exit IP each time)
    """
    sid = session_id if sticky and session_id else uuid.uuid4().hex[:10]
    username = f"{user_base}-session-{sid}"
    if country:
        username += f"-country-{country}"
    proxy_url = f"http://{username}:{password}@{host}:{port}"
    return {"http": proxy_url, "https": proxy_url}

# Scraping: rotate every request
def scrape_page(url):
    proxies = build_proxy(PROXY_HOST, PROXY_PORT, "user", PROXY_PASS, sticky=False)
    return requests.get(url, proxies=proxies, timeout=15)

# Login flow / account session: pin the same exit IP across the whole flow
def account_session(login_payload):
    session_proxies = build_proxy(PROXY_HOST, PROXY_PORT, "user", PROXY_PASS,
                                   sticky=True, session_id="acct-flow-42")
    s = requests.Session()
    s.post("https://example.com/login", proxies=session_proxies, data=login_payload)
    return s.get("https://example.com/dashboard", proxies=session_proxies)

curl -x http://user-session-test1-country-DE-city-berlin:[email protected]:7000 \
  https://ipinfo.io/json

def verify_geo(expected_country, expected_city=None):
    proxies = build_proxy(PROXY_HOST, PROXY_PORT, "user", PROXY_PASS,
                           country=expected_country, sticky=True, session_id="geo-check")
    resp = requests.get("https://ipinfo.io/json", proxies=proxies, timeout=10)
    data = resp.json()
    match = data.get("country") == expected_country
    print(f"Requested: {expected_country} | Got: {data.get('country')} | Match: {match}")
    return data