Skip to content
Proxy fundamentals

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.

On this page 9 sections
  1. What the error covers, and what it does not
  2. Test the proxy outside the browser first
  3. The causes, most likely first
  4. 1. The setting points at a program that is no longer running
  5. 2. Chrome is not using the system setting at all
  6. 3. A typo, or a proxy name that does not resolve
  7. 4. The proxy is down, or a firewall is in the way
  8. 5. The scheme does not match what the port speaks
  9. 6. A PAC file that names a dead proxy
  10. When the proxy answers but will not open the tunnel
  11. Proxy authentication
  12. TLS interception
  13. The same failures in Python and Node
  14. Cloudflare 10xx errors are a different problem
  15. How this was tested

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 Drawn from the table below.
Time from navigation to failure in Chrome 155, two runs per case, local loopback proxies. Bar chart of Run 1 (s), Run 2 (s) by Case.5 rows, drawn from the table that follows this chart.Closed proxy portClosed proxy port · Run 1 (s): 0.1470.147Closed proxy port · Run 2 (s): 0.1240.124Proxy name does not resolveProxy name does not resolve · Run 1 (s): 0.1190.119Proxy name does not resolve · Run 2 (s): 0.1260.126https:// on a plain proxyhttps:// on a plain proxy · Run 1 (s): 0.1330.133https:// on a plain proxy · Run 2 (s): 0.1490.149Proxy IP drops packetsProxy IP drops packets · Run 1 (s): 8.1798.179Proxy IP drops packets · Run 2 (s): 8.1088.108socks5:// on an HTTP proxysocks5:// on an HTTP proxy · Run 1 (s): 30.14830.148socks5:// on an HTTP proxy · Run 2 (s): 30.11330.11305101520253035 sTime from navigation to failure in Chrome 155, two runs per case, local loopback proxies. Bar chart of Run 1 (s), Run 2 (s) by Case.5 rows, drawn from the table that follows this chart.Closed proxy portClosed proxy port · Run 1 (s): 0.1470.147Closed proxy port · Run 2 (s): 0.1240.124Proxy name does notresolveProxy name does not resolve · Run 1 (s): 0.1190.119Proxy name does not resolve · Run 2 (s): 0.1260.126https:// on a plain proxyhttps:// on a plain proxy · Run 1 (s): 0.1330.133https:// on a plain proxy · Run 2 (s): 0.1490.149Proxy IP drops packetsProxy IP drops packets · Run 1 (s): 8.1798.179Proxy IP drops packets · Run 2 (s): 8.1088.108socks5:// on an HTTPproxysocks5:// on an HTTP proxy · Run 1 (s): 30.14830.148socks5:// on an HTTP proxy · Run 2 (s): 30.11330.11302040 s
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 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 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 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 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 and 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 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 and the Node.js proxy guide.

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)
  2. Chromium source: http_proxy_connect_job.cc (error mapping and proxy connection timeout)
  3. Chromium source: socks_connect_job.cc
  4. Chromium source: proxy_fallback.cc (errors that trigger proxy fallback)
  5. Chromium: Proxy support in Chrome
  6. Chromium: error page strings
  7. Chromium: Linux proxy config
  8. Chromium policy definition: ProxyMode
  9. Chrome for Developers: chrome.proxy API
  10. Microsoft Support: Use a proxy server in Windows
  11. Apple Support: Change proxy settings on Mac
  12. RFC 9110 section 9.3.6: CONNECT
  13. RFC 9110 section 15.5.8: 407 Proxy Authentication Required
  14. libcurl error codes
  15. Requests documentation: SSL certificate verification
  16. Cloudflare One Client modes (Local proxy mode)
  17. Cloudflare: 1xxx errors
  18. Cloudflare: Error 1000
  19. Cloudflare: Error 1003
  20. Cloudflare: Error 1005
  21. Cloudflare: Errors 1006, 1007, 1008 or 1106
  22. Cloudflare: Error 1009
  23. Cloudflare: Error 1010
  24. Cloudflare: Error 1012
  25. Cloudflare: Error 1015
  26. Cloudflare: Error 1020
  27. Cloudflare: Ray ID
  28. RFC 6761: Special-Use Domain Names (.invalid)
  29. RFC 5737: IPv4 address blocks reserved for documentation
  30. Squid 6.13 source: cf.data.pre (default SSL_ports list and the deny CONNECT !SSL_ports rule)

Read this page as Markdown · Quote it freely under CC BY 4.0 with a link back.