Proxy Error Codes: Complete Reference

# Test SOCKS5 auth with curl
curl --socks5 user:pass@proxy.coronium.io:1080 \
  https://httpbin.org/ip -v

# Python with PySocks
import socks
import socket

socks.set_default_proxy(
    socks.SOCKS5, "proxy.coronium.io", 1080,
    username="user", password="pass"
)
socket.socket = socks.socksocket

# Or with requests + socks
import requests
proxies = {"https": "socks5://user:pass@proxy.coronium.io:1080"}
resp = requests.get("https://httpbin.org/ip", proxies=proxies)

# Verify the target port is correct and service is running
# First test directly (if possible)
curl -v https://target-site.com:443

# Then test through SOCKS5
curl --socks5-hostname user:pass@proxy.coronium.io:1080 \
  https://target-site.com:443 -v

# Common port issues:
# - Using port 80 instead of 443 for HTTPS
# - Target redirects to a different port
# - Service only listens on specific interfaces

# Diagnose TTL/routing issues
# Use --socks5-hostname to let proxy handle DNS
curl --socks5-hostname user:pass@proxy.coronium.io:1080 \
  https://target-site.com -v

# If the above fails, the proxy cannot reach the target
# Try a proxy in a different region/network
curl --socks5-hostname user:pass@proxy-us.coronium.io:1080 \
  https://target-site.com -v

# Verify DNS resolution at proxy level
# (SOCKS5 with -hostname flag delegates DNS to proxy)

# Test with multiple proxy regions to isolate network issue
regions = ["us", "de", "uk", "sg"]
for region in regions:
    proxy = f"socks5://user:pass@proxy-{region}.coronium.io:1080"
    try:
        resp = requests.get(target_url, proxies={"https": proxy}, timeout=15)
        print(f"{region}: {resp.status_code}")
    except Exception as e:
        print(f"{region}: {e}")
# If all fail -> target is truly down
# If some succeed -> regional routing issue

# Verify proxy is listening
# Test TCP connection with nc (netcat)
nc -zv proxy.coronium.io 8080

# Test with curl verbose
curl -x http://user:pass@proxy.coronium.io:8080 \
  https://httpbin.org/ip -v

# Common port assignments:
# HTTP proxy: 8080, 3128, 80
# SOCKS5: 1080, 1085
# HTTPS proxy: 8443

# Diagnose timeout: is it the proxy or the target?
import requests
import time

proxy = "http://user:pass@proxy.coronium.io:8080"

# Step 1: Test proxy connectivity (fast target)
start = time.time()
try:
    resp = requests.get("https://httpbin.org/ip",
                        proxies={"https": proxy}, timeout=10)
    print(f"Proxy OK: {time.time()-start:.1f}s")
except requests.exceptions.ConnectTimeout:
    print("ETIMEDOUT: Cannot reach proxy server")
except requests.exceptions.ReadTimeout:
    print("Proxy connected but target timed out")

# Step 2: If proxy works, test target directly
try:
    resp = requests.get("https://target-site.com", timeout=10)
    print("Target reachable directly -> proxy routing issue")
except:
    print("Target unreachable directly too -> target is down")

# Handle ECONNRESET with retry and fresh connections
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

session = requests.Session()
retry = Retry(
    total=3,
    backoff_factor=1,  # 1s, 2s, 4s
    status_forcelist=[502, 503, 504],
    allowed_methods=["GET", "POST"],
)
adapter = HTTPAdapter(
    max_retries=retry,
    pool_connections=10,
    pool_maxsize=10,
)
session.mount("https://", adapter)
session.mount("http://", adapter)

# Disable keep-alive to force fresh connections
session.headers["Connection"] = "close"

resp = session.get(url, proxies={"https": proxy}, timeout=30)

# SOCKS5 vs SOCKS5h: the DNS leak difference
# SOCKS5 (local DNS, LEAKS):
proxies = {"https": "socks5://user:pass@proxy:1080"}

# SOCKS5h (proxy-side DNS, SAFE):
proxies = {"https": "socks5h://user:pass@proxy:1080"}

# curl: --socks5 vs --socks5-hostname
# LEAKS DNS:
curl --socks5 user:pass@proxy:1080 https://target.com
# SAFE (proxy resolves DNS):
curl --socks5-hostname user:pass@proxy:1080 https://target.com

# Test for DNS leak:
# Visit https://dnsleaktest.com through your proxy
# If you see your ISP DNS servers -> DNS is leaking

# Debug DNS resolution through proxy
# Test if proxy can resolve the domain
curl --socks5-hostname user:pass@proxy:1080 \
  https://target-site.com -v 2>&1 | grep "Resolving"

# Alternative: use a known-working domain first
curl --socks5-hostname user:pass@proxy:1080 \
  https://httpbin.org/ip -v

# If httpbin works but target doesn't:
# -> DNS issue specific to that domain at proxy location
# Try proxy in a different region

def retry_with_backoff(func, max_retries=5):
    for attempt in range(max_retries):
        try:
            result = func()
            if result.status_code in [429, 503]:
                retry_after = result.headers.get("Retry-After")
                wait = int(retry_after) if retry_after else (2 ** attempt) + random.uniform(0, 1)
                time.sleep(wait)
                continue
            return result
        except (ConnectionError, Timeout):
            time.sleep((2 ** attempt) + random.uniform(0, 1))
    raise MaxRetriesExceeded()

class ProxyPool:
    def __init__(self, proxies):
        self.proxies = {p: {"score": 100, "cooldown_until": 0} for p in proxies}

    def get_proxy(self):
        now = time.time()
        available = [p for p, s in self.proxies.items()
                     if s["score"] > 20 and s["cooldown_until"] < now]
        return random.choice(available) if available else None

    def report_error(self, proxy, status_code):
        if status_code == 403:
            self.proxies[proxy]["score"] -= 50
            self.proxies[proxy]["cooldown_until"] = time.time() + 3600
        elif status_code == 429:
            self.proxies[proxy]["score"] -= 20
            self.proxies[proxy]["cooldown_until"] = time.time() + 300

    def report_success(self, proxy):
        self.proxies[proxy]["score"] = min(100, self.proxies[proxy]["score"] + 5)

async def health_check(proxy, timeout=5):
    try:
        resp = requests.get("https://httpbin.org/ip",
                            proxies={"https": proxy}, timeout=timeout)
        if resp.status_code == 200:
            ip = resp.json().get("origin")
            return {"healthy": True, "ip": ip, "latency_ms": resp.elapsed.total_seconds() * 1000}
    except Exception as e:
        return {"healthy": False, "error": str(e)}

# Run health checks on all proxies before scraping session
healthy_proxies = []
for proxy in all_proxies:
    result = await health_check(proxy)
    if result["healthy"] and result["latency_ms"] < 5000:
        healthy_proxies.append(proxy)
print(f"{len(healthy_proxies)}/{len(all_proxies)} proxies healthy")

class CircuitBreaker:
    CLOSED, OPEN, HALF_OPEN = "closed", "open", "half_open"

    def __init__(self, failure_threshold=5, recovery_timeout=60):
        self.state = self.CLOSED
        self.failures = 0
        self.threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.last_failure_time = 0

    def can_execute(self):
        if self.state == self.CLOSED:
            return True
        if self.state == self.OPEN:
            if time.time() - self.last_failure_time > self.recovery_timeout:
                self.state = self.HALF_OPEN
                return True  # Allow one test request
            return False
        return True  # HALF_OPEN: allow test

    def record_success(self):
        self.failures = 0
        self.state = self.CLOSED

    def record_failure(self):
        self.failures += 1
        self.last_failure_time = time.time()
        if self.failures >= self.threshold:
            self.state = self.OPEN