Error Handling & Retries

{
  "error": "rate_limited",
  "message": "Too many requests. Please implement backoff.",
  "status": 429,
  "retry_after": 5,
  "request_id": "req_abc123def456"
}

import requests
import time
import random

def fetch_with_retry(url: str, proxies: dict, max_retries: int = 5) -> requests.Response:
    """Fetch URL through proxy with exponential backoff and jitter."""
    for attempt in range(max_retries):
        try:
            response = requests.get(url, proxies=proxies, timeout=30)
            
            if response.status_code == 200:
                return response
            
            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 5))
                time.sleep(retry_after)
                continue
            
            if response.status_code >= 500:
                # Server error — retry with backoff
                wait = min(2 ** attempt + random.uniform(0, 1), 60)
                time.sleep(wait)
                continue
            
            # 4xx — don't retry (client error)
            response.raise_for_status()
            
        except requests.exceptions.Timeout:
            wait = min(2 ** attempt + random.uniform(0, 1), 60)
            time.sleep(wait)
        except requests.exceptions.ConnectionError:
            wait = min(2 ** attempt + random.uniform(0, 1), 60)
            time.sleep(wait)
    
    raise Exception(f"Failed after {max_retries} retries: {url}")

# Usage
proxies = {
    "http": "http://customer-USERNAME-cc-US:PASSWORD@gate.zentislabs.com:8080",
    "https": "http://customer-USERNAME-cc-US:PASSWORD@gate.zentislabs.com:8080",
}

response = fetch_with_retry("https://example.com/api/data", proxies)
print(response.json())

import requests
import time
import random

def fetch_with_rotation(url: str, max_retries: int = 5) -> requests.Response:
    """Retry with a fresh proxy IP on each attempt."""
    for attempt in range(max_retries):
        session_id = f"retry-{attempt}-{random.randint(1000, 9999)}"
        proxy = f"http://customer-USERNAME-cc-US-sessid-{session_id}:PASSWORD@gate.zentislabs.com:8080"
        proxies = {"http": proxy, "https": proxy}
        
        try:
            response = requests.get(url, proxies=proxies, timeout=30)
            if response.status_code == 200:
                return response
            
            print(f"Attempt {attempt + 1}: Status {response.status_code}, rotating IP...")
            
        except requests.RequestException as e:
            print(f"Attempt {attempt + 1}: {e}, rotating IP...")
        
        wait = min(2 ** attempt + random.uniform(0, 1), 30)
        time.sleep(wait)
    
    raise Exception(f"Failed after {max_retries} retries with rotation")

import axios, { AxiosError } from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";

async function fetchWithRetry(
  url: string,
  maxRetries = 5,
): Promise<any> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const sessionId = `retry-${attempt}-${Date.now()}`;
    const agent = new HttpsProxyAgent(
      `http://customer-USERNAME-cc-US-sessid-${sessionId}:PASSWORD@gate.zentislabs.com:8080`
    );

    try {
      const { data } = await axios.get(url, {
        httpsAgent: agent,
        timeout: 30000,
      });
      return data;
    } catch (err) {
      const status = (err as AxiosError).response?.status;
      
      if (status && status >= 400 && status < 500 && status !== 429) {
        throw err; // Don't retry client errors (except 429)
      }

      const wait = Math.min(2 ** attempt * 1000 + Math.random() * 1000, 60000);
      console.log(`Attempt ${attempt + 1} failed (${status}), retrying in ${wait}ms...`);
      await new Promise((r) => setTimeout(r, wait));
    }
  }
  throw new Error(`Failed after ${maxRetries} retries: ${url}`);
}

import requests

PROXY_CHAIN = [
    "http://customer-USERNAME-cc-US-sesstype-residential:PASSWORD@gate.zentislabs.com:8080",
    "http://customer-USERNAME-cc-US-sesstype-isp:PASSWORD@gate.zentislabs.com:8080",
    "http://customer-USERNAME-cc-US-sesstype-datacenter:PASSWORD@gate.zentislabs.com:8080",
]

def fetch_with_failover(url: str) -> requests.Response:
    """Try each proxy type in order until one succeeds."""
    for proxy_url in PROXY_CHAIN:
        proxies = {"http": proxy_url, "https": proxy_url}
        try:
            response = requests.get(url, proxies=proxies, timeout=30)
            if response.status_code == 200:
                return response
        except requests.RequestException:
            continue
    raise Exception("All proxy types failed")

response = fetch_with_failover("https://example.com/data")

# If a specific city fails, fall back to broader targeting
GEO_CHAIN = [
    "customer-USERNAME-cc-US-city-new-york",   # Most specific
    "customer-USERNAME-cc-US-state-NY",         # State level
    "customer-USERNAME-cc-US",                   # Country level
]

def fetch_with_geo_failover(url: str) -> requests.Response:
    for username in GEO_CHAIN:
        proxy = f"http://{username}:PASSWORD@gate.zentislabs.com:8080"
        proxies = {"http": proxy, "https": proxy}
        try:
            response = requests.get(url, proxies=proxies, timeout=30)
            if response.status_code == 200:
                return response
        except requests.RequestException:
            continue
    raise Exception("All geo levels failed")