How to Rotate Proxies in Python (2026 Guide)

By Marcus Reiner · 2026-05-11 · 14 min read · Engineering

Rotating proxies in Python isn't hard — once you know the patterns. Here are the working code recipes for 2026.

How to rotate proxies in Python: the short answer

The most reliable way to rotate proxies in Python in 2026 is through a provider's backconnect gateway - a single hostname and port that automatically assigns a new IP per request or per session, so your code never manages an IP list directly. This works identically whether you use requests, httpx or aiohttp, since you simply point your proxy configuration at the gateway credentials rather than a list of individual IPs.

Client-side rotation through a manually maintained IP list is the legacy approach and is only worth using if you are self-hosting your own proxy pool or your provider does not offer a gateway; for anyone using a commercial provider like Decodo, the gateway method is simpler, more reliable and requires far less code.

Option 1: Backconnect gateway (recommended)

A backconnect gateway is a proxy endpoint - for example Decodo's gateway at gate.decodo.com on a fixed port - that sits in front of the provider's entire IP pool and rotates the exit IP automatically according to your account's rotation settings, without any code-side logic required.

Setting this up in Python with the requests library requires nothing more than passing the gateway URL with embedded credentials as your proxy dictionary; every request through that session can land on a different IP with zero additional code.

• proxies = {"http": "http://user:[email protected]:7000", "https": "http://user:[email protected]:7000"}
• response = requests.get("https://example.com", proxies=proxies, timeout=15)
• For sticky sessions, append a session ID to the username: user-session-abc123:[email protected]:7000

Option 2: Client-side IP list rotation

If you are managing your own list of proxy IPs rather than using a gateway, rotation means picking a different entry from that list on each request, typically using Python's random.choice or a round-robin index, and updating the requests proxies dictionary before each call.

This approach requires you to handle dead IP detection yourself - removing IPs that return connection errors or timeouts from the active pool - and to periodically refresh the list if your provider issues new IPs, adding meaningful maintenance overhead compared to a managed gateway.

• proxy_list = ["http://ip1:port", "http://ip2:port", "http://ip3:port"]
• current_proxy = random.choice(proxy_list)
• response = requests.get(url, proxies={"http": current_proxy, "https": current_proxy}, timeout=15)

Sticky sessions in Python

Sticky sessions hold the same exit IP for a configured duration, useful for multi-page scrapes or login flows that need consistency across several requests. With a gateway-based provider like Decodo, this is done by embedding a session identifier in the proxy username so the gateway maps that identifier to a fixed backend IP for the session's lifetime, typically up to 30 minutes.

In practice you generate a random session ID once per logical task, reuse the same requests.Session object with that session ID baked into the proxy credentials for every request in that task, then generate a fresh session ID for the next unrelated task to force a new IP.

• session_id = str(uuid.uuid4())[:8]
• proxy_user = "user-session-" + session_id
• proxies = {"http": "http://" + proxy_user + ":[email protected]:7000"}
• s = requests.Session(); s.proxies.update(proxies) # reuse s for every request in this task

Async rotation with aiohttp

For high-throughput scraping, asynchronous requests via aiohttp let you fire many concurrent requests through the rotating gateway, with each concurrent request naturally landing on a different IP since the gateway rotates per-connection by default.

The pattern is the same as with requests - pass the gateway URL as the proxy parameter on each request call - but wrapped in an asyncio.gather to run many requests concurrently, dramatically increasing throughput for large scraping jobs.

• async with aiohttp.ClientSession() as session:
• async with session.get(url, proxy="http://user:[email protected]:7000") as resp:
• html = await resp.text()
• tasks = [fetch(session, url) for url in url_list]; results = await asyncio.gather(*tasks)

Rotation with httpx

httpx supports both sync and async clients with the same proxy configuration pattern as requests and aiohttp, and is a reasonable modern alternative for teams wanting HTTP/2 support alongside proxy rotation.

The proxy is configured once on the client instantiation rather than per-request, and because a single httpx.AsyncClient can be reused across many concurrent requests, it is a common choice for large async scraping pipelines built after 2023.

• client = httpx.AsyncClient(proxies="http://user:[email protected]:7000", timeout=15)
• resp = await client.get(url)

Retry logic and error handling

Proxy rotation is not a substitute for retry logic - even a high-quality provider will occasionally return connection errors, timeouts or non-200 status codes from a specific exit IP, and your scraper needs to handle these gracefully rather than treating them as fatal errors.

A standard pattern is to wrap each request in a retry loop with exponential backoff, generating a new session ID (forcing a new exit IP) on each retry, and giving up after a configured maximum attempt count while logging the failure for later analysis.

• for attempt in range(4):
• try: resp = requests.get(url, proxies=proxies, timeout=15); if resp.status_code == 200: break
• except requests.exceptions.RequestException: time.sleep(2 ** attempt); proxies = get_fresh_proxy()

Common HTTP status codes and what they mean

429 (Too Many Requests) usually means your current IP has hit a rate limit on the target - rotate to a new IP and slow your request rate. 403 (Forbidden) often means the target's anti-bot system flagged the request outright, which may require a residential proxy upgrade or additional stealth measures rather than just a new IP.

407 (Proxy Authentication Required) means your proxy credentials are wrong or your IP is not whitelisted if the provider uses IP whitelisting instead of user/pass auth. Connection timeouts frequently indicate a dead or overloaded exit IP, which a gateway-based provider should route around automatically on the next request.

• 429 -> rotate IP, add delay between requests
• 403 -> target detected automation; consider residential/mobile proxy or a managed unblocker
• 407 -> check proxy credentials and IP whitelist settings
• Timeout -> retry with a new session ID; check provider status page if persistent

Common mistakes

The most common mistake is reusing the same requests.Session object across unrelated tasks without changing the session ID, which unintentionally keeps the same exit IP far longer than intended and defeats the purpose of rotation.

Another mistake is setting retry loops without any delay or backoff, hammering the target and the proxy gateway simultaneously and making rate-limiting worse rather than better.

Teams also frequently hardcode a single proxy configuration across an entire codebase rather than centralizing it in one config function, making it painful to switch providers or adjust rotation behavior later.

Verdict

For nearly all Python scraping workloads in 2026, use a provider's backconnect gateway rather than managing your own IP list - Decodo's gateway setup takes under five minutes and handles rotation, sticky sessions and dead-IP avoidance automatically. Pair it with proper retry logic and status-code-aware error handling, and consider Bright Data or Oxylabs if you need a managed unblocker layered on top for harder anti-bot targets.

Frequently Asked Questions