Residential Proxy Best Practices

Residential proxies provide IP addresses from real ISPs across 195+ countries. They carry the highest trust level of any proxy type — but using them effectively requires understanding rotation, targeting, bandwidth management, and anti-detection patterns. Follow these best practices to achieve 95%+ success rates.

Understanding Residential IP Pools

Hex Proxies' residential network provides rotating IP addresses from genuine residential ISPs worldwide. Each request can route through a different IP, or you can use sticky sessions to maintain the same IP. The pool is massive — providing IP diversity that makes fingerprinting practically impossible.

Best Practice 1: Country Targeting

Always target the country closest to your use case:

import httpx

def get_residential_proxy(username: str, password: str, country: str = "") -> str: user = f"{username}-country-{country.lower()}" if country else username return f"http://{user}:{password}@gate.hexproxies.com:8080"

Target US for US-specific content us_proxy = get_residential_proxy("YOUR_USER", "YOUR_PASS", "US")

Target UK for UK pricing uk_proxy = get_residential_proxy("YOUR_USER", "YOUR_PASS", "GB") ```

Why this matters: Many sites serve different content by country. Using a US proxy to scrape UK pricing returns US prices — which is wrong data.

Best Practice 2: Optimize Bandwidth

Residential plans are typically billed per GB. Minimize waste:

1. Always send compression headers: Accept-Encoding: gzip, deflate, br
2. Block unnecessary resources in browser automation (images, videos, fonts)
3. Use HEAD requests when you only need status codes
4. Cache responses for pages you visit repeatedly
5. Extract only the data you need — do not store full HTML for simple data points

Best Practice 3: Request Pacing

Residential IPs have high trust, but they are not invincible:

import random
import asyncio

async def paced_fetch(url: str, proxy: str) -> str: # Random delay mimics human browsing patterns await asyncio.sleep(random.uniform(1.5, 4.0)) async with httpx.AsyncClient(proxy=proxy, timeout=30) as client: resp = await client.get(url, headers={ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", "Accept": "text/html,application/xhtml+xml", "Accept-Encoding": "gzip, deflate, br", }) return resp.text ```

Best Practice 4: Session Strategy

Best Practice 5: Error Handling

Residential networks have slightly higher variance than ISP proxies. Build robust error handling:

async def resilient_fetch(url: str, username: str, password: str, max_retries: int = 3) -> dict:
    for attempt in range(max_retries):
        proxy = get_residential_proxy(username, password)
        try:
            async with httpx.AsyncClient(proxy=proxy, timeout=20) as client:
                resp = await client.get(url)
                if resp.status_code == 200:
                    return {"success": True, "body": resp.text, "attempts": attempt + 1}
                if resp.status_code in (403, 429):
                    await asyncio.sleep(2 ** attempt)
                    continue
        except (httpx.TimeoutException, httpx.ConnectError):
            await asyncio.sleep(1)
            continue
    return {"success": False, "body": "", "attempts": max_retries}

Best Practice 6: Monitor Usage

Track your residential bandwidth consumption: - Set up daily usage alerts in the Hex Proxies dashboard - Log per-request bandwidth to identify wasteful patterns - Compare bandwidth vs success rate — high bandwidth with low success indicates blocked requests re-downloading error pages

Cost Optimization Summary

Hex Proxies' ethically-sourced residential network supports SOCKS5, HTTP, and HTTPS with country-level targeting across 195+ countries on multi-Gbps capacity.