On this page 9 sections
- What the error covers, and what it does not
- Test the proxy outside the browser first
- The causes, most likely first
- 1. The setting points at a program that is no longer running
- 2. Chrome is not using the system setting at all
- 3. A typo, or a proxy name that does not resolve
- 4. The proxy is down, or a firewall is in the way
- 5. The scheme does not match what the port speaks
- 6. A PAC file that names a dead proxy
- When the proxy answers but will not open the tunnel
- Proxy authentication
- TLS interception
- The same failures in Python and Node
- Cloudflare 10xx errors are a different problem
- 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.
| 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,502or503: the proxy is reachable, and your problem is no longerERR_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?
Is ERR_PROXY_CONNECTION_FAILED caused by the website I am visiting?
How do I turn off the proxy that causes ERR_PROXY_CONNECTION_FAILED?
What is the difference between ERR_PROXY_CONNECTION_FAILED and ERR_TUNNEL_CONNECTION_FAILED?
Why do I get ERR_TIMED_OUT instead of ERR_PROXY_CONNECTION_FAILED?
Does a Cloudflare error 1020 mean my proxy is broken?
Sources
- Chromium source: net_error_list.h (ERR_PROXY_CONNECTION_FAILED is -130)
- Chromium source: http_proxy_connect_job.cc (error mapping and proxy connection timeout)
- Chromium source: socks_connect_job.cc
- Chromium source: proxy_fallback.cc (errors that trigger proxy fallback)
- Chromium: Proxy support in Chrome
- Chromium: error page strings
- Chromium: Linux proxy config
- Chromium policy definition: ProxyMode
- Chrome for Developers: chrome.proxy API
- Microsoft Support: Use a proxy server in Windows
- Apple Support: Change proxy settings on Mac
- RFC 9110 section 9.3.6: CONNECT
- RFC 9110 section 15.5.8: 407 Proxy Authentication Required
- libcurl error codes
- Requests documentation: SSL certificate verification
- Cloudflare One Client modes (Local proxy mode)
- Cloudflare: 1xxx errors
- Cloudflare: Error 1000
- Cloudflare: Error 1003
- Cloudflare: Error 1005
- Cloudflare: Errors 1006, 1007, 1008 or 1106
- Cloudflare: Error 1009
- Cloudflare: Error 1010
- Cloudflare: Error 1012
- Cloudflare: Error 1015
- Cloudflare: Error 1020
- Cloudflare: Ray ID
- RFC 6761: Special-Use Domain Names (.invalid)
- RFC 5737: IPv4 address blocks reserved for documentation
- Squid 6.13 source: cf.data.pre (default SSL_ports list and the deny CONNECT !SSL_ports rule)