---
title: "ERR_PROXY_CONNECTION_FAILED: what it means and how to fix it"
url: https://proxy.wiki/guides/err-proxy-connection-failed/
type: Guide
author: "proxy.wiki editorial"
published: 2026-10-21
updated: 2026-10-21
site: proxy.wiki
topics: ["Proxy fundamentals"]
license: CC BY 4.0; quote freely with attribution to https://proxy.wiki/
---

# ERR_PROXY_CONNECTION_FAILED: what it means and how to fix it

> ERR_PROXY_CONNECTION_FAILED means Chrome could not reach its proxy. Each cause reproduced, with the command that finds it and the fix.

## Key takeaways

- ERR_PROXY_CONNECTION_FAILED (Chromium error -130) means Chrome could not resolve or connect to the proxy itself; the website was never contacted.
- If the proxy answered at all, with a 407, 403, 502 or 503, Chrome shows a different error, usually ERR_TUNNEL_CONNECTION_FAILED.
- Test the same proxy with curl -x: exit 5 is a bad proxy hostname, exit 7 a closed port, exit 28 no answer at all.
- The setting may come from a flag, an extension or a policy rather than the system; check chrome://version, chrome://extensions and chrome://policy.
- A Cloudflare 10xx page means the proxy worked and the site owner's configuration answered.

`ERR_PROXY_CONNECTION_FAILED` means Chrome could not open a connection to the proxy server it was told to use. Either the proxy’s hostname did not resolve, or the TCP connection to it failed, or, for an `https://` proxy, the TLS handshake with it failed. The website you asked for was never contacted. Usually the fix is on your own machine: a proxy setting that points at something that is not there any more.

This is the page Chrome 155 showed us with its proxy set to a closed port on the same machine:

```
No Internet
There is something wrong with the proxy server or the address is incorrect.
Try:
Contacting the system admin
Checking the proxy address
ERR_PROXY_CONNECTION_FAILED
```

That capture came from an English (non-US) locale. The US English source string in Chromium reads “There is something wrong with the proxy server, or the address is incorrect.” with a comma, under the heading “No internet”. The wording changes with the language. The code at the bottom does not, which is why it is the thing to search for.

Automation sees the same failure without the page. Over the DevTools protocol, `Page.navigate` returned `errorText: "net::ERR_PROXY_CONNECTION_FAILED"`, and headless Chrome logged this line to stderr:

```
ERROR:components/headless/command_handler/headless_command_handler.cc:403] Page load failed: net::ERR_PROXY_CONNECTION_FAILED
```

## What the error covers, and what it does not

Chromium defines the code in `net/base/net_error_list.h` as error -130. The comment says it covers two steps: resolving the proxy’s name, and connecting a socket to it. It then excludes, in capitals, failures during the `CONNECT` method of an HTTP proxy. The code that produces it matches that comment. In `http_proxy_connect_job.cc`, any failure on the connection to the first proxy, other than a certificate error or a request for a client certificate, is returned as `ERR_PROXY_CONNECTION_FAILED`, and `socks_connect_job.cc` does the same for SOCKS proxies.

That boundary is the most useful fact on this page. If the proxy answered at all, even with a refusal, Chrome reports something else. So the error tells you where to look: between your machine and the proxy’s front door, not at the website and not at whatever sits behind the proxy.

We built each failure on loopback and recorded what Chrome 155 reported, then ran curl against the same setups. Method and versions are in the last section.

| What was wrong | Chrome 155 reported | curl 8.7.1 reported | Where to look | Fix |
| --- | --- | --- | --- | --- |
| Nothing listening on the proxy port | ERR_PROXY_CONNECTION_FAILED | (7) Failed to connect to 127.0.0.1 port 24999 after 0 ms: Couldn't connect to server | System proxy settings; is the proxy app running? | Start the proxy or VPN client again, or remove the setting |
| Proxy hostname does not resolve | ERR_PROXY_CONNECTION_FAILED | (5) Could not resolve proxy: proxy.invalid | dig +short on the proxy hostname | Correct the hostname, or fix DNS |
| SOCKS5 proxy port closed | ERR_PROXY_CONNECTION_FAILED | (7) Failed to connect to 127.0.0.1 port 24999 after 0 ms: Couldn't connect to server | Same as a closed HTTP proxy port | Start the SOCKS service, or correct the port |
| https:// scheme set for a plain HTTP proxy | ERR_PROXY_CONNECTION_FAILED | (35) LibreSSL/3.3.6: error:1404B42E:SSL routines:ST_CONNECT:tlsv1 alert protocol version | openssl s_client against the proxy port | Use http:// for the proxy URL |
| PAC file returns only a dead proxy | ERR_PROXY_CONNECTION_FAILED | — | Fetch the PAC file and read FindProxyForURL | Fix the proxy, or have the PAC return a working one |
| Proxy IP silently drops packets | ERR_TIMED_OUT after 8.1 s | (28) Failed to connect to 192.0.2.1 port 3128 after 5010 ms: Timeout was reached (with --connect-timeout 5) | nc -vz with a timeout | Correct the address, or open the firewall path |
| socks5:// scheme set for an HTTP proxy | ERR_TIMED_OUT after 30.1 s | (28) Connection timed out after 20005 milliseconds (our --max-time 20) | Compare the scheme with the provider’s documentation | Use the scheme the proxy actually speaks |
| HTTPS proxy with an untrusted certificate | ERR_PROXY_CERTIFICATE_INVALID | — | openssl s_client shows the certificate | Fix the proxy’s certificate or trust its CA |
| Proxy accepts, then resets | ERR_CONNECTION_RESET | (56) Recv failure: Connection reset by peer | Proxy logs; a dead backend behind a port forward | Fix the service behind the port |
| Proxy wants credentials (407) | ERR_INVALID_AUTH_CREDENTIALS (headless) | (56) CONNECT tunnel failed, response 407 | curl -v, read the Proxy-Authenticate header | Send the right credentials |
| Proxy refuses the tunnel (403, 502, 503) | ERR_TUNNEL_CONNECTION_FAILED | (56) CONNECT tunnel failed, response 503 | curl -w '%{http_connect}' | Depends on the status; see the CONNECT section |
| Proxy intercepts TLS, CA not trusted | NET::ERR_CERT_AUTHORITY_INVALID | (60) SSL certificate problem: self signed certificate | Certificate issuer in the browser or openssl s_client | Install the organisation’s CA properly, or stop the interception |

Two rows surprised us. A proxy address that drops packets did not produce `ERR_PROXY_CONNECTION_FAILED` at all; Chrome gave up after about eight seconds with `ERR_TIMED_OUT`, in both runs. The source explains it. On desktop, `http_proxy_connect_job.cc` derives a proxy connection timeout from Chrome’s estimate of the network round-trip time and, by default, clamps it between 8 and 30 seconds. A job that hits its timeout ends as `ERR_TIMED_OUT`. The second surprise was the scheme mix-up: pointing `https://` at a plain proxy fails fast with the proxy error, while pointing `socks5://` at the same proxy hangs for 30 seconds first. That figure matches the 30-second SOCKS handshake timeout in `socks_connect_job.cc`. The TCP connection succeeds, squid waits for an HTTP request line that never comes, and Chrome’s SOCKS greeting gets no reply until the timer fires.

_Time from navigation to failure in Chrome 155, two runs per case, local loopback proxies_

| Case | Run 1 (s) | Run 2 (s) | Error |
| --- | --- | --- | --- |
| Closed proxy port | 0.147 | 0.124 | ERR_PROXY_CONNECTION_FAILED |
| Proxy name does not resolve | 0.119 | 0.126 | ERR_PROXY_CONNECTION_FAILED |
| https:// on a plain proxy | 0.133 | 0.149 | ERR_PROXY_CONNECTION_FAILED |
| Proxy IP drops packets | 8.179 | 8.108 | ERR_TIMED_OUT |
| socks5:// on an HTTP proxy | 30.148 | 30.113 | ERR_TIMED_OUT |

## Test the proxy outside the browser first

Chrome folds several different failures into one code. curl does not, so one command run against the exact proxy address Chrome is using tells you which of them you have:

```
curl -sS --connect-timeout 5 -o /dev/null \
  -w 'connect=%{http_connect} http=%{http_code}\n' \
  -x http://HOST:PORT https://example.com/
echo "exit=$?"
```

Against a working proxy it prints `connect=200 http=200` and `exit=0`. Against a closed port it prints:

```
curl: (7) Failed to connect to 127.0.0.1 port 24999 after 0 ms: Couldn't connect to server
connect=000 http=000
exit=7
```

Read the result like this:

- **Exit 5**: the proxy’s name did not resolve.

- **Exit 7**: nothing accepted the connection.

- **Exit 28**: nothing answered within the timeout.

- **Exit 35**: the TLS handshake failed. Against a proxy URL that often means the scheme is wrong.

- **`connect=407`, `403`, `502` or `503`**: the proxy is reachable, and your problem is no longer `ERR_PROXY_CONNECTION_FAILED`.

Our guide to [using a proxy with curl](/guides/how-to-use-a-proxy-with-curl/) covers the flags in more detail.

If you only want to know whether the port is open, `nc` is quicker. These are real outputs from macOS’s `nc` against a closed port, an open one, and an address that drops packets:

```
$ nc -vz 127.0.0.1 24999
nc: connectx to 127.0.0.1 port 24999 (tcp) failed: Connection refused
$ nc -vz 127.0.0.1 24129
Connection to 127.0.0.1 port 24129 [tcp/*] succeeded!
$ nc -vz -G 5 192.0.2.1 3128
nc: connectx to 192.0.2.1 port 3128 (tcp) failed: Operation timed out
```

In code, httpx 0.28.1 separates the cases more cleanly than requests does, because it raises different exception classes for each hop. This is the check we ran against our test proxies:

```
import sys
import httpx

def check_proxy(proxy: str, url: str = "https://example.com/") -> str:
    """Say which hop failed: the connection to the proxy, the proxy's answer, or TLS."""
    try:
        with httpx.Client(proxy=proxy, timeout=httpx.Timeout(10.0, connect=5.0)) as c:
            r = c.get(url)
        return f"ok: {r.status_code} through the proxy"
    except httpx.ProxyError as e:          # the proxy answered CONNECT with a non-2xx
        return f"proxy answered but refused the tunnel: {e}"
    except httpx.ConnectTimeout:
        return "no answer from the proxy address (dropped, filtered or wrong IP)"
    except httpx.ConnectError as e:        # refused, unresolvable, or TLS failure
        if "CERTIFICATE_VERIFY_FAILED" in str(e):
            if proxy.startswith("https://"):   # the proxy's own certificate comes first
                return f"proxy's certificate not trusted (or interception): {e}"
            return f"tunnel open, certificate not trusted (interception?): {e}"
        return f"could not reach the proxy itself: {e}"

if __name__ == "__main__":
    print(check_proxy(sys.argv[1], *sys.argv[2:]))
```

```
http://127.0.0.1:24129     -> ok: 200 through the proxy
http://127.0.0.1:24999     -> could not reach the proxy itself: [Errno 61] Connection refused
http://proxy.invalid:3128  -> could not reach the proxy itself: [Errno 8] nodename nor servname provided, or not known
http://192.0.2.1:3128      -> no answer from the proxy address (dropped, filtered or wrong IP)
https://127.0.0.1:24129    -> could not reach the proxy itself: [SSL: WRONG_VERSION_NUMBER] wrong version number (_ssl.c:1010)
http://127.0.0.1:24128     -> proxy answered but refused the tunnel: 407 Proxy Authentication Required
https://127.0.0.1:24204    -> proxy's certificate not trusted (or interception): [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self-signed certificate (_ssl.c:1010)
http://127.0.0.1:24203     -> tunnel open, certificate not trusted (interception?): [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self-signed certificate (_ssl.c:1010)
```

## The causes, most likely first

The order below is our judgement of what is most likely on a desktop that worked yesterday. It is not a measured frequency.

### 1. The setting points at a program that is no longer running

Many desktop proxy and VPN tools work by listening on a local port and pointing the system or individual apps at it. When the tool quits, crashes or is uninstalled and the setting stays behind, every request goes to a closed port, and Chrome shows `ERR_PROXY_CONNECTION_FAILED` within a fraction of a second. Cloudflare’s own client is a documented example. In Local proxy mode the Cloudflare One Client (formerly WARP) listens on `127.0.0.1`, port `40000` by default, and applications or the system proxy settings have to be pointed at it explicitly. Turn the client off and those settings point at nothing.

Find out where the setting lives. On macOS these commands only read:

```
scutil --proxy
networksetup -getwebproxy Wi-Fi
networksetup -getsecurewebproxy Wi-Fi
networksetup -getautoproxyurl Wi-Fi
```

A clean machine looks like this; anything with `Enabled: Yes` and a host you do not recognise is the suspect:

```
$ networksetup -getwebproxy Wi-Fi
Enabled: No
Server:
Port: 0
Authenticated Proxy Enabled: 0
```

In the macOS interface the same settings are under System Settings, Network, the network service, Details, Proxies. On Windows 10 and 11 they are under Settings, Network & internet, Proxy, and Microsoft notes that a VPN connection has its own proxy settings, set separately under that VPN’s advanced options. That second location is easy to miss. On Linux, Chromium reads GNOME or KDE proxy settings when it detects those desktops, and otherwise takes command-line flags or environment variables.

The fix is to start the tool again, or switch the manual proxy off. Then test with the curl command above before reopening Chrome.

### 2. Chrome is not using the system setting at all

Chromium’s proxy documentation lists four places Chrome’s proxy configuration can come from: managed policy, command-line flags such as `--proxy-server`, per-profile extensions using the `chrome.proxy` API, and the system settings. If the system says there is no proxy and Chrome still shows the error, one of the other three is in charge.

The settings page will not always tell you. We launched Chrome 155 with `--proxy-server=http://127.0.0.1:24999`, and its System settings row still read only “Open your computer’s proxy settings”. The flag was visible at `chrome://version`, on the Command Line row:

```
Command Line   .../Google Chrome --headless=new --user-data-dir=<profile> --remote-debugging-port=0 --no-first-run --proxy-server=http://127.0.0.1:24999 --noerrdialogs --flag-switches-begin --flag-switches-end about:blank
```

Check three pages. `chrome://version` for flags, which usually come from a shortcut or a launcher script. `chrome://policy` for a proxy policy; Chromium’s definition of the ProxyMode policy (deprecated in favour of ProxySettings, but still defined) says that setting it stops users changing proxy settings and makes Chrome ignore proxy options given on the command line. `chrome://extensions` for anything with the proxy permission; the extension API documentation notes that the effective settings can be determined by another extension or by a policy. Remove the flag, disable the extension, or ask whoever manages the policy.

Do not expect `chrome://net-internals/#proxy` to show the settings. In Chrome 155 that tab holds two buttons, “Re-apply settings” and “Clear bad proxies”, and nothing else. To see the effective configuration, record a log at `chrome://net-export` while you reproduce the failure. Open it in the NetLog viewer. Its Proxy tab shows the original and effective settings, and any proxies Chrome has marked as bad.

### 3. A typo, or a proxy name that does not resolve

Chrome shows the same error for `proxy.invalid` as for a closed port, so a mistyped hostname looks exactly like a dead proxy. curl tells them apart: exit 5, “Could not resolve proxy”, versus exit 7. Check the name directly with `dig +short gateway.example.net` or `nslookup`. If it resolves on one network and not another, a VPN or corporate DNS is involved. If you copied the gateway from a provider dashboard, compare it character by character, including the port.

### 4. The proxy is down, or a firewall is in the way

A refused connection is fast and gives `ERR_PROXY_CONNECTION_FAILED`. A dropped one is slow and, in our runs, gave `ERR_TIMED_OUT` instead. Both mean the same thing for you: nothing answered at that address. Run `nc -vz -G 5 HOST PORT` from the same machine, then from a different network if you can. If it fails everywhere, the proxy service is down or the address is wrong. If it fails only on your network, an outbound firewall rule, an office network policy or security software is blocking that port. Whoever runs the proxy can confirm which.

### 5. The scheme does not match what the port speaks

A proxy URL carries a scheme, and Chrome believes it. Write `https://` in front of a plain HTTP proxy and Chrome opens a TLS handshake the proxy does not understand. The handshake failure is not a certificate error, so Chromium reports it as `ERR_PROXY_CONNECTION_FAILED`. You can see the mismatch with OpenSSL 4.0.3:

```
$ openssl s_client -connect 127.0.0.1:24129 -brief </dev/null
Connecting to 127.0.0.1
80A1C5FB01000000:error:0A00010B:SSL routines:tls_validate_record_header:wrong version number:ssl/record/methods/tlsany_meth.c:67:
```

“wrong version number” here means the far end answered in plain text. The reverse mistake, a real HTTPS proxy whose certificate Chrome does not trust, gets its own code, `ERR_PROXY_CERTIFICATE_INVALID`, and its own page: “This site can’t be reached”. Writing `socks5://` for an HTTP proxy does not fail fast at all; Chrome waited 30 seconds and showed `ERR_TIMED_OUT`. Use the scheme your provider documents for that port. HTTP proxying and [SOCKS5](/glossary/socks5/) are different protocols, and a port that speaks one will not answer the other.

### 6. A PAC file that names a dead proxy

With automatic configuration, a PAC script decides the proxy for each URL. A script that returns `PROXY 127.0.0.1:24999` and nothing else produced `ERR_PROXY_CONNECTION_FAILED` in our test. The same script returning `PROXY 127.0.0.1:24999; DIRECT` loaded the page, because Chrome treats a connection failure to a proxy as grounds to try the next entry in the list. The same works on the command line, which is the example Chromium’s documentation gives. On macOS we ran it as:

```
"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" \
  --proxy-server="http://127.0.0.1:24999,direct://"
```

On Linux the binary is usually `google-chrome`; the flag is the same.

A PAC URL that cannot be fetched at all did not cause the error either: Chrome silently went direct. Chromium documents that behaviour and two exceptions. With system settings on a platform that supports it, such as Windows, the manual proxy servers are used instead. A PAC script marked mandatory through the extension API does not fall back at all, and requests then fail with `ERR_MANDATORY_PROXY_CONFIGURATION_FAILED`.

Falling back to `DIRECT` hides a broken proxy by sending the request from your own address. For a scraper or anything where the exit address matters, that is a leak, not a fix. Keep the failure loud and fix the proxy.

To diagnose, fetch the script with curl, read what `FindProxyForURL` returns for the failing host, and test that proxy with the curl check above.

## When the proxy answers but will not open the tunnel

For an `https://` page, the browser asks the proxy to open a tunnel with `CONNECT host:443`. RFC 9110 is blunt about the result: any 2xx response means the tunnel is open, and any other response means it is not. Chrome reported each 403, 502 and 503 we tried as `ERR_TUNNEL_CONNECTION_FAILED` and did not show the status. curl does. This is squid 6.13 refusing because it could not reach the destination (some lines trimmed):

```
$ curl -sv -o /dev/null -x http://127.0.0.1:24129 https://127.0.0.1:24999/
* Connected to 127.0.0.1 (127.0.0.1) port 24129
* Establish HTTP proxy tunnel to 127.0.0.1:24999
> CONNECT 127.0.0.1:24999 HTTP/1.1
> Host: 127.0.0.1:24999
> User-Agent: curl/8.7.1
> Proxy-Connection: Keep-Alive
>
< HTTP/1.1 503 Service Unavailable
< Server: squid/6.13
< X-Squid-Error: ERR_CONNECT_FAIL 61
* CONNECT tunnel failed, response 503
```

The `61` in `X-Squid-Error` is the operating system’s error number, “Connection refused” on macOS. Other proxies put their reason in a different header or in the body, so read the whole response. Squid gave us three variants, and Chrome reported all of them as `ERR_TUNNEL_CONNECTION_FAILED`: a policy refusal (403), a destination that refused the connection (503), and a destination name that did not resolve (also 503). The 403 came from a rule squid ships in its default configuration, `http_access deny CONNECT !SSL_ports`, which refuses `CONNECT` to any port outside the `SSL_ports` list. In the squid 6.13 defaults that list holds only 443. A plain `http://` URL behaves differently, because there is no tunnel. Chrome displays the proxy’s own error page instead. Ours said “The requested URL could not be retrieved” and “The system returned: (61) Connection refused”.

What to change depends on the status. A 403 is the proxy’s policy: a blocked port or domain. A 502 or 503 means the proxy tried and the destination did not answer it, so test the destination from somewhere else before blaming the proxy. Our [403 vs 407 vs 429 guide](/guides/403-vs-407-vs-429/) covers which system sends which status.

## Proxy authentication

A proxy that wants credentials answers `CONNECT` with `407 Proxy Authentication Required` and a `Proxy-Authenticate` header. Desktop Chrome shows a sign-in prompt for the proxy at that point; we did not test that path. Headless Chrome cannot ask, and reported `net::ERR_INVALID_AUTH_CREDENTIALS` with the 407 status attached. Neither is `ERR_PROXY_CONNECTION_FAILED`, because the proxy answered.

The libraries are less clear. requests 2.34.2 wraps the 407 in a message that says it was “Unable to connect to proxy”, although it connected fine:

```
requests.exceptions.ProxyError: HTTPSConnectionPool(host='example.com', port=443): Max retries exceeded with url: / (Caused by ProxyError('Unable to connect to proxy', OSError('Tunnel connection failed: 407 Proxy Authentication Required')))
```

undici 7.16.0’s `ProxyAgent` was vaguer still. For the 407, the 502 and the 503 alike, `fetch` threw `TypeError: fetch failed` with the cause `Request was cancelled.` and no status anywhere. If a Node job fails that way, repeat the request with `curl -v` to see what the proxy actually said. Fix the credentials, percent-encode any special characters in them, or add your address to the provider’s allowlist. The [proxy authentication](/glossary/proxy-authentication/) entry explains the header exchange.

## TLS interception

Some proxies open the tunnel and then terminate TLS themselves, presenting their own certificate for the site. Corporate inspection gateways and debugging proxies work this way. If the client does not trust the proxy’s CA, the tunnel succeeds and the certificate check fails, so the error is about the certificate, not the connection. Our fake interceptor, which answers `CONNECT` with 200 and then presents a self-signed certificate for `example.com`, produced these:

```
Chrome 155:    Your connection is not private ... NET::ERR_CERT_AUTHORITY_INVALID
curl 8.7.1:    curl: (60) SSL certificate problem: self signed certificate
requests:      requests.exceptions.SSLError: ... [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self-signed certificate (_ssl.c:1010)
undici 7.16.0: Error [DEPTH_ZERO_SELF_SIGNED_CERT]: self-signed certificate; if the root CA is installed locally, try running Node.js with --use-system-ca
```

If the interceptor belongs to your organisation, trust its root certificate where each client reads trust from. For the browser that is the operating system store. For curl it is `--cacert`. For requests it is the `REQUESTS_CA_BUNDLE` environment variable, which the requests documentation describes for exactly this case. If you did not expect anyone to be inspecting your traffic, treat the warning as a warning. Turning verification off makes every one of these errors go away and removes the only thing that told you. More background is in the [TLS interception](/glossary/tls-interception/) and [certificate pinning](/glossary/certificate-pinning/) entries.

## The same failures in Python and Node

These are the exceptions each library raised for the cases above, trimmed to the part that identifies the cause. Proxies were passed in code, not through environment variables; if you rely on `HTTPS_PROXY`, our [environment variables guide](/guides/proxy-environment-variables/) lists which variable each tool reads.

| Case | requests 2.34.2 | httpx 0.28.1 | undici 7.16.0 on Node 24.2.0 |
| --- | --- | --- | --- |
| Closed proxy port | ProxyError … NewConnectionError … [Errno 61] Connection refused | httpx.ConnectError: [Errno 61] Connection refused | fetch failed, cause ECONNREFUSED |
| Proxy name does not resolve | ProxyError … NameResolutionError … Failed to resolve 'proxy.invalid' | httpx.ConnectError: [Errno 8] nodename nor servname provided, or not known | fetch failed, cause ENOTFOUND |
| Proxy IP drops packets | ProxyError … ConnectTimeoutError … (connect timeout=5) | httpx.ConnectTimeout: timed out | UND_ERR_CONNECT_TIMEOUT after 10 s |
| 407 from the proxy | ProxyError … Tunnel connection failed: 407 Proxy Authentication Required | httpx.ProxyError: 407 Proxy Authentication Required | fetch failed, cause Request was cancelled. |
| 503 from the proxy | ProxyError … Tunnel connection failed: 503 Service Unavailable | httpx.ProxyError: 503 Service Unavailable | fetch failed, cause Request was cancelled. |
| Proxy accepts, then resets | ConnectionError: ('Connection aborted.', ConnectionResetError(54, ...)) | httpx.ReadError: [Errno 54] Connection reset by peer | — |

Language-specific setup, including the `proxy=` versus `proxies=` change in httpx, is in the [Python proxy guide](/guides/proxies-in-python-requests-httpx/) and the [Node.js proxy guide](/guides/proxies-in-nodejs/).

## Cloudflare 10xx errors are a different problem

A Cloudflare error page with a four-digit code starting with 10 is the opposite case. Your request got through the proxy, reached Cloudflare’s edge, and Cloudflare answered on the site’s behalf. Here is the simplest one we could produce without touching anyone’s protection: a plain request for one of Cloudflare’s own addresses, sent through our local squid.

```
$ curl -sS -D - -x http://127.0.0.1:24129 http://104.16.132.229/
HTTP/1.1 403 Forbidden
Content-Type: text/plain; charset=UTF-8
Server: cloudflare
CF-RAY: a4e2ba91de6a0d4f-[edge code removed]
Via: 1.1 proxy-test (squid/6.13)

error code: 1003
```

(Headers trimmed.) The `Via` line shows the request passed through squid, and the `Server` line shows Cloudflare answered. Error 1003, in Cloudflare’s documentation, means direct access to a Cloudflare IP address is not allowed; browse to the domain name instead. The codes people meet behind proxies are mostly access decisions the site owner configured:

| Code | What Cloudflare’s documentation says it means | If you are the visitor | If you own the site |
| --- | --- | --- | --- |
| 1000 | DNS points to a prohibited IP. Listed causes include a record pointing at a Cloudflare IP, a second reverse proxy in front, an X-Forwarded-For header longer than 100 characters, two X-Forwarded-For headers, or a CF-Connecting-IP header in the request | Check whether your proxy adds forwarding headers; otherwise report it to the site | Point the record at the origin; remove the loop through another proxy |
| 1003 | Direct IP access not allowed | Use the domain name, not a Cloudflare IP | — |
| 1005 | The owner banned the autonomous system number (ASN) | Send the owner a screenshot of the error | Find the Ray ID or IP in Security Events; review IP Access rules |
| 1006, 1007, 1008, 1106 | Your IP address has been banned | Ask the owner to review the block; Cloudflare support cannot override it | Review the security settings that matched |
| 1009 | The owner banned your country or region | Contact the owner | Check IP Access rules for the reported IP |
| 1010 | Banned based on the browser’s signature | Notify the owner | Browser Integrity Check can be turned off in Security settings |
| 1012 | Access denied for malicious activity detected from the visitor’s computer or network | Cloudflare suggests a full antivirus scan, then contacting the owner | — |
| 1015 | You are being rate limited | Wait, and do not retry rapidly, which can extend the block | Review rate limiting thresholds |
| 1020 | A security rule with a Block action matched; returned with HTTP 403 | Send the owner a screenshot of the error | Search Security Events for the Ray ID or client IP to find the rule |

Behind a proxy, the client IP Cloudflare shows and logs is the proxy’s exit address, not yours. That matters for both sides. A visitor sharing an exit with other users can inherit a block they did not cause. An owner who looks up the Ray ID will find a proxy’s address and should judge the rule with that in mind. Cloudflare’s pages say the same thing several times: the site owner set the rule, and only the site owner can change it. We do not cover ways around a specific site’s protection. If you run the site, the Ray ID on the page (also sent as the `cf-ray` header) is the key to the Security Events log.

## How this was tested

All captures were made on 21 October 2026 on an arm64 Mac. Chrome 155.0.8059.85 ran headless (`--headless=new`) with a fresh profile per case. A Node 24.2.0 script drove it over the DevTools protocol and recorded the document request’s `Network.loadingFailed` error and the text of the page Chrome displayed. The other clients were curl 8.7.1 (SecureTransport, LibreSSL 3.3.6), Python 3.12.13 with requests 2.34.2, urllib3 2.8.0 and httpx 0.28.1, and undici 7.16.0 on Node 24.2.0. The proxies were squid 6.13 (one open port, one requiring Basic credentials) and four small Python servers: one that accepts and resets, one that answers every request with 502, a TLS listener with a self-signed certificate, and one that intercepts TLS. The refused cases used a port with nothing listening.

There were 22 Chrome cases and each ran twice. One case in the second run, TLS interception, failed inside our harness before Chrome loaded the page, so we ran it a third time; it gave the same error as the first run. Every other error code matched across the two runs. Timings in the chart are the interval between `Page.navigate` and the failure event. The control, the same Chrome flags pointed at the open squid port, loaded `https://example.com/` with status 200 in every run. Unreachable names and addresses were chosen so they can never be real: `.invalid` is reserved by RFC 6761 and `192.0.2.0/24` by RFC 5737. Chrome sends `localhost` and `127.0.0.0/8` direct by default, so cases with a loopback destination used `--proxy-bypass-list="<-loopback>"`, as Chromium’s documentation describes.

Not tested: Windows and Linux builds, desktop Chrome’s credential prompt, other browsers, and real commercial proxy gateways, which put different text in their error responses. The error codes come from Chromium’s network stack, which other Chromium-based browsers share, but we only ran Chrome.

## Frequently asked questions

### What does ERR_PROXY_CONNECTION_FAILED mean?

Chrome could not open a connection to the proxy server in its settings: the proxy's hostname did not resolve, or the TCP or TLS connection to it failed. Chromium defines it as error -130 in net_error_list.h. The website itself was never contacted.

### Is ERR_PROXY_CONNECTION_FAILED caused by the website I am visiting?

No. The failure happens before any request reaches the site. Check the proxy address Chrome is using, whether anything is listening on it, and where the setting came from.

### How do I turn off the proxy that causes ERR_PROXY_CONNECTION_FAILED?

Chrome uses the operating system's proxy settings unless a policy, an extension or a command-line flag overrides them. Switch off the manual proxy in the system settings (Windows: Settings, Network & internet, Proxy; macOS: System Settings, Network, Details, Proxies). Then check chrome://version for a --proxy-server flag, chrome://extensions for a proxy extension and chrome://policy for a managed setting.

### What is the difference between ERR_PROXY_CONNECTION_FAILED and ERR_TUNNEL_CONNECTION_FAILED?

ERR_PROXY_CONNECTION_FAILED means Chrome never connected to the proxy. ERR_TUNNEL_CONNECTION_FAILED means it connected, sent CONNECT for an https:// page, and the proxy answered with something other than a 2xx, such as 403, 502 or 503. curl shows that status, for example "CONNECT tunnel failed, response 503".

### Why do I get ERR_TIMED_OUT instead of ERR_PROXY_CONNECTION_FAILED?

If the proxy address silently drops packets instead of refusing them, Chrome's attempt runs into its own proxy connection timeout. In our runs Chrome 155 gave up after about 8 seconds with ERR_TIMED_OUT. The cause is the same: nothing is answering at the proxy address.

### Does a Cloudflare error 1020 mean my proxy is broken?

No. A Cloudflare 10xx page means your request went through the proxy and reached Cloudflare. Cloudflare documents 1020 as a site owner's security rule with a Block action, returned with HTTP 403. Only the site owner can change it; send them the Ray ID shown on the page.

## Sources

1. [Chromium source: net_error_list.h (ERR_PROXY_CONNECTION_FAILED is -130)](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/net/base/net_error_list.h)
2. [Chromium source: http_proxy_connect_job.cc (error mapping and proxy connection timeout)](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/net/http/http_proxy_connect_job.cc)
3. [Chromium source: socks_connect_job.cc](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/net/socket/socks_connect_job.cc)
4. [Chromium source: proxy_fallback.cc (errors that trigger proxy fallback)](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/net/http/proxy_fallback.cc)
5. [Chromium: Proxy support in Chrome](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/net/docs/proxy.md)
6. [Chromium: error page strings](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/components/error_page_strings.grdp)
7. [Chromium: Linux proxy config](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/docs/linux/proxy_config.md)
8. [Chromium policy definition: ProxyMode](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/components/policy/resources/templates/policy_definitions/Proxy/ProxyMode.yaml)
9. [Chrome for Developers: chrome.proxy API](https://developer.chrome.com/docs/extensions/reference/api/proxy)
10. [Microsoft Support: Use a proxy server in Windows](https://support.microsoft.com/en-us/windows/use-a-proxy-server-in-windows-03096c53-0554-4ffe-b6ab-8b1deee8dae1)
11. [Apple Support: Change proxy settings on Mac](https://support.apple.com/guide/mac-help/change-proxy-settings-on-mac-mchlp2591/mac)
12. [RFC 9110 section 9.3.6: CONNECT](https://www.rfc-editor.org/rfc/rfc9110.html#section-9.3.6)
13. [RFC 9110 section 15.5.8: 407 Proxy Authentication Required](https://www.rfc-editor.org/rfc/rfc9110.html#section-15.5.8)
14. [libcurl error codes](https://curl.se/libcurl/c/libcurl-errors.html)
15. [Requests documentation: SSL certificate verification](https://requests.readthedocs.io/en/latest/user/advanced/#ssl-cert-verification)
16. [Cloudflare One Client modes (Local proxy mode)](https://developers.cloudflare.com/cloudflare-one/team-and-resources/devices/cloudflare-one-client/configure/modes/)
17. [Cloudflare: 1xxx errors](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/)
18. [Cloudflare: Error 1000](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1000/)
19. [Cloudflare: Error 1003](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1003/)
20. [Cloudflare: Error 1005](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1005/)
21. [Cloudflare: Errors 1006, 1007, 1008 or 1106](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1006/)
22. [Cloudflare: Error 1009](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1009/)
23. [Cloudflare: Error 1010](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1010/)
24. [Cloudflare: Error 1012](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1012/)
25. [Cloudflare: Error 1015](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1015/)
26. [Cloudflare: Error 1020](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1020/)
27. [Cloudflare: Ray ID](https://developers.cloudflare.com/fundamentals/reference/cloudflare-ray-id/)
28. [RFC 6761: Special-Use Domain Names (.invalid)](https://www.rfc-editor.org/rfc/rfc6761.html)
29. [RFC 5737: IPv4 address blocks reserved for documentation](https://www.rfc-editor.org/rfc/rfc5737.html)
30. [Squid 6.13 source: cf.data.pre (default SSL_ports list and the deny CONNECT !SSL_ports rule)](https://github.com/squid-cache/squid/blob/SQUID_6_13/src/cf.data.pre)
