Python requests ProxyError: Retries and Backoff for Proxies

What ProxyError means and the 3 usual causes

ProxyError is a subclass of ConnectionError, so it is raised before the target site answers. The text at the end of the message tells you which case it is. In our local test a refused login ended with "Tunnel connection failed: 407 Proxy Authentication Required" and a closed port ended with "Connection refused".

Cause 1: wrong host, port or protocol. The Proxy302 gateway uses port 2222 for HTTP and 3333 for SOCKS5. A SOCKS5 address in requests also needs pip install "requests[socks]". Cause 2: the login is refused (407) because of a typo, a missing special character or a password with @ that was not percent-encoded in the URL. Cause 3: the asset has ended: a rented IP past its end date, or a traffic balance that is used up.

Not every failure is a ProxyError. A response with status 429 or 503 is a normal reply from the site or gateway, and a timeout is its own exception. They need different handling, as the table shows.

• python requests proxy setup
• address and port guide

• Sources:
• Requests source: requests.exceptions
• Local test of the code on this page
• Proxy302 product facts and price list
• Requests docs: Advanced usage

What to do with each failure

Based on the Requests source, the urllib3 Retry docs, MDN and our local test of 13 November 2026. The "yes" rows are advice for a small number of attempts, not a promise that a retry succeeds.

• Sources:
• Requests source: requests.exceptions
• urllib3 docs: urllib3.util.Retry
• MDN: 429 Too Many Requests
• Local test of the code on this page

Fix and harden in 5 steps

1. Step 1: Read the end of the error text

   Print str(exc) once. 407 means the login, Connection refused or a timeout means the address, port or protocol, or an ended asset.

2. Step 2: Test the same proxy with curl

   Run curl -x http://LOGIN:PASSWORD@HOST:2222 https://ipinfo.io/json with the values from My assets. If curl works and Python does not, check the proxies dictionary and the environment proxy variables, which can override session.proxies.

   • proxy authentication (407) guide

3. Step 3: Set a timeout on every call

   Without a timeout a request never gives up. Use a tuple such as timeout=(3.05, 20): connect and read are set separately.

4. Step 4: Add retries with backoff

   For plain status codes mount a Retry adapter (first code block). To also handle ProxyError and the 407 stop rule, use the loop in the second code block.

5. Step 5: Cap the attempts and log the last error

   Three or four attempts are enough for a temporary fault. After that, stop and record the last error text so you can see the real cause.

Retry adapter for status codes

import requests
from requests.adapters import HTTPAdapter
from urllib3.util import Retry

PROXY = "http://LOGIN:PASSWORD@HOST:2222"
PROXIES = {"http": PROXY, "https": PROXY}

retries = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[429, 502, 503, 504],
    allowed_methods={"GET"},
)
session = requests.Session()
session.mount("https://", HTTPAdapter(max_retries=retries))
session.mount("http://", HTTPAdapter(max_retries=retries))

response = session.get("https://ipinfo.io/json", proxies=PROXIES, timeout=(3.05, 20))
print(response.status_code, response.text)

Example only: replace LOGIN, PASSWORD and HOST with the values from My assets; percent-encode special characters such as @ in the login. The sleep between retries is backoff_factor * 2 ** previous retries.

• Sources:
• Requests docs: Advanced usage
• urllib3 docs: urllib3.util.Retry

A loop that stops on a wrong login

import random
import time

import requests

PROXY = "http://LOGIN:PASSWORD@HOST:2222"
PROXIES = {"http": PROXY, "https": PROXY}
RETRY_STATUS = {429, 502, 503, 504}
MAX_ATTEMPTS = 4


def fetch(url):
    last_error = None
    for attempt in range(1, MAX_ATTEMPTS + 1):
        delay = min(2 ** attempt, 30)  # 2, 4, 8, 16 seconds
        try:
            # a new Session opens a new connection, so a rotating line can give a new IP
            with requests.Session() as session:
                response = session.get(url, proxies=PROXIES, timeout=(3.05, 20))
            if response.status_code not in RETRY_STATUS:
                return response
            retry_after = response.headers.get("Retry-After", "")
            if retry_after.isdigit():
                delay = min(int(retry_after), 60)  # the server said how long to wait
            last_error = RuntimeError(f"HTTP {response.status_code}")
        except requests.exceptions.ProxyError as exc:
            if "407" in str(exc):
                raise  # wrong login: retrying will not help
            last_error = exc
        except (requests.exceptions.ConnectTimeout, requests.exceptions.ReadTimeout) as exc:
            last_error = exc
        if attempt < MAX_ATTEMPTS:
            time.sleep(delay + random.uniform(0, 1))
    raise RuntimeError(f"gave up after {MAX_ATTEMPTS} attempts: {last_error}")


if __name__ == "__main__":
    print(fetch("https://ipinfo.io/json").text)

Example only, with placeholder login. Each attempt opens a new Session, and therefore a new connection; on a rotating line a new connection gets a new IP. The 407 check reads the error text, which our local test confirmed on requests 2.32.5.

• Sources:
• Local test of the code on this page
• Requests docs: Advanced usage
• MDN: 429 Too Many Requests

Retries and rotation on Proxy302

On rotating residential every new connection gets a new IP, but a requests.Session keeps its connection alive, so many calls on one Session usually share one IP. That is why the loop above opens a fresh Session per attempt. Static ISP and datacenter IPs do not rotate during the lease, so a retry through them uses the same IP; they cost from US$0.25 (datacenter) and US$0.50 (static ISP) for 1 day.

Keep the number of attempts small. On per-GB lines every attempt that reaches the site uses traffic. There is no free trial; the smallest purchase is 1 GB of rotating residential traffic or one IP for one day.

• rotating residential proxies
• test that every connection gets a new IP

• Sources:
• Proxy302 product facts and price list
• Requests docs: Advanced usage

FAQ

Read next

More on proxies in Python.

Web scraping proxies

Web scraping proxies on real household IPs in 195+ countries and regions: rotating exits or sticky sessions by major city, from US$1.50/GB, HTTP and SOCKS5.

View options and pricing

Python requests proxy setup

How to use HTTP and SOCKS5 proxies in Python requests: examples, timeouts and an IP check.

Fix ERR_PROXY_CONNECTION_FAILED

The ERR_PROXY_CONNECTION_FAILED error appears in Chrome and Edge when the browser cannot establish a connection with a proxy server.

Scrapy rotating proxy

Scrapy with one rotating proxy endpoint: meta or middleware, retry defaults for 8 status codes, AutoThrottle and a spider that logs the exit IP.

Rotating residential proxies

Real household IPs in 195+ countries; the Premium line adds state and major-city targeting. A new IP on every new connection, or keep sticky sessions. From US$1.50/GB, US$1.35/GB at 100 GB. HTTP and SOCKS5.

View options and pricing