---
title: "ERR_EMPTY_RESPONSE: what it means and how to fix it"
url: https://proxy.wiki/guides/err-empty-response/
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_EMPTY_RESPONSE: what it means and how to fix it

> ERR_EMPTY_RESPONSE means a server or proxy closed the connection without sending a byte. Causes we reproduced, how to tell them apart, and fixes.

## Key takeaways

- ERR_EMPTY_RESPONSE means the connection opened and the request went out, then the other end closed without sending a single byte.
- The other end can be the site, a proxy, or local software that intercepts HTTPS. A proxy that closes instead of answering CONNECT gives ERR_EMPTY_RESPONSE, not ERR_TUNNEL_CONNECTION_FAILED.
- A standards-following proxy such as Squid turns an origin's empty reply into a 502, and Cloudflare turns it into a 520, so the browser never sees the empty reply.
- Chrome resends the request on a reused or preconnected socket before it shows the error: a server that failed after 3 s cost 6 to 9 s in our runs.
- In scripts, retry idempotent requests once. httpx transport retries do not cover this error; a urllib3 Retry with read=1 does.

Chrome shows this page when a connection opened, the request went out, and the other end closed the connection without sending a single byte back:

```
This page isn’t working
127.0.0.1 didn’t send any data.
ERR_EMPTY_RESPONSE
```

Puppeteer and Playwright report the same thing as `net::ERR_EMPTY_RESPONSE at http://127.0.0.1:37181/`. Chromium defines the code, number -324, in a single line of its source: “The server closed the connection without sending any data.” The server in that sentence is whatever Chrome was connected to. That can be the website, a [proxy](/glossary/forward-proxy/) between you and the website, or software on your own computer that intercepts HTTPS.

Two things follow. DNS resolved and the TCP connection was accepted, so flushing DNS or resetting the network stack rarely changes anything. And something read your request, then closed before writing a status line, so the fix belongs to whichever hop did the closing. Apart from one certificate check and one header check against public sites, every output on this page was captured on one machine against local servers and proxies we set up to fail in one specific way each. The setup is at the end.

## What each client prints for the same failure

One server, one behaviour: it reads the request, closes the connection with a normal TCP FIN, and sends nothing. This is what each client reported.

| Client | Version | What it reports |
| --- | --- | --- |
| Google Chrome (driven by Playwright) | 155.0.8059.85 | net::ERR_EMPTY_RESPONSE |
| curl | 8.7.1 | curl: (52) Empty reply from server |
| Python requests | 2.34.2 | ConnectionError: ('Connection aborted.', RemoteDisconnected('Remote end closed connection without response')) |
| Python httpx | 0.28.1 | httpx.RemoteProtocolError: Server disconnected without sending a response. |
| Node.js built-in fetch | 24.2.0 (undici 7.10.0) | TypeError: fetch failed, cause SocketError: other side closed (UND_ERR_SOCKET) |
| Node.js node:http | 24.2.0 | Error: socket hang up, code ECONNRESET |

curl’s documentation describes exit code 52 as “Nothing was returned from the server, and under the circumstances, getting nothing is considered an error.” Python raises `RemoteDisconnected` when reading the response finds no data at all. The trap is `node:http`. It labels a clean close `ECONNRESET`, the same code it uses for a genuine reset. Read the message instead: “socket hang up” means nothing came back, while “read ECONNRESET” means the peer reset the connection.

The verbose curl output shows exactly where it stops. The request is sent in full and the very next event is the close:

```
$ curl -sv http://127.0.0.1:37181/
*   Trying 127.0.0.1:37181...
* Connected to 127.0.0.1 (127.0.0.1) port 37181
> GET / HTTP/1.1
> Host: 127.0.0.1:37181
> User-Agent: curl/8.7.1
> Accept: */*
>
* Request completely sent off
* Empty reply from server
* Closing connection
```

## Empty response or reset? Settle that first

We changed the same server to abort the connection with a TCP RST instead of closing it (SO_LINGER set to zero). Every client then reported something different:

```
Chrome    net::ERR_CONNECTION_RESET  ("This site can’t be reached. The connection was reset.")
curl      curl: (56) Recv failure: Connection reset by peer
requests  ConnectionError: ('Connection aborted.', ConnectionResetError(54, 'Connection reset by peer'))
httpx     httpx.ReadError: [Errno 54] Connection reset by peer
fetch     TypeError: fetch failed, cause: read ECONNRESET
```

Chromium’s error list ties the names to the packets: `ERR_CONNECTION_CLOSED` is commented “corresponding to a TCP FIN” and `ERR_CONNECTION_RESET` “corresponding to a TCP RST”. `ERR_EMPTY_RESPONSE` is the FIN case on a fresh connection that delivered zero bytes. If your page says “connection was reset”, you are looking at a related but different failure. The fastest way to tell them apart outside the browser is the curl exit code: 52 for an empty reply, 56 for a reset.

## Three commands that narrow it down

- **Same URL, same machine, no browser:** `curl -sv https://site.example/path -o /dev/null`. Exit 52 means the far end sent nothing. If curl succeeds, the problem is in the browser profile or something only the browser uses.

- **If a proxy is involved:** repeat with `-x http://user:pass@gw.example.net:8000`. A proxy that answers prints a status line such as `HTTP/1.1 407` or `503`; one that hangs up prints `Proxy CONNECT aborted`.

- **If it is HTTPS:** check who issued the certificate (the `openssl` command under cause 5). An issuer that is not a public certificate authority means something on the path is decrypting your traffic.

## Causes and how to fix each one

The order below is our judgment of where to look first, not a measured frequency. Each cause comes with the output we captured, a command that tells it apart from the others, and the fix.

### 1. The application died or gave up mid-request

We ran a stock Node.js 24.2.0 HTTP server whose handler never answers, with `server.timeout` set to 2000. Node’s documentation calls that value “the number of milliseconds of inactivity before a socket is presumed to have timed out”; its default is 0, which disables it. With no `'timeout'` listener attached, Node destroyed the socket after two seconds. curl exited 52 after 2.002 s. Chrome showed `ERR_EMPTY_RESPONSE` after 4.1 s, because it sent the request twice (more on that below).

A crashed worker, a process killed for using too much memory, or an application server’s own request timeout all look identical from the client. Cloudflare’s documentation for its 520 error makes the same observation from the CDN side, noting that these errors “are prevalent with certain PHP applications that crash the origin web server.”

Diagnose by timing it. A failure that lands on a round number points at a timeout somebody configured:

```
$ curl -sS -o /dev/null -w '%{time_total}s exit=%{exitcode} http=%{http_code}\n' http://127.0.0.1:37186/
curl: (52) Empty reply from server
2.002238s exit=52 http=000
```

Fix, if you run the site: read the application’s error log at that timestamp, fix the crash or raise the timeout, and put a reverse proxy in front if there is none, so a dead upstream becomes a readable 502 instead of silence. If you are only visiting, nothing on your side will fix it. Report the URL and the time to the site owner.

### 2. The server closed the connection on purpose

Some servers are configured to hang up without a word. nginx documents this directly: “The non-standard code 444 closes a connection without sending a response header.” Administrators use `return 444;` for requests with an unknown `Host` header, for scanners, or for clients a rule has decided to refuse. A firewall or application filter set to drop rather than reject produces the same result.

Diagnose: if every URL on the host fails the same instant way, while other sites load, the server or something just in front of it is refusing your connection. Site owners can find the rule quickly:

```
grep -rn "return 444" /etc/nginx/
```

Fix: only the operator can change it. As a visitor, tell them what you saw and when.

### 3. Plain HTTP sent to an HTTPS port

Sending `http://127.0.0.1:37444/` to a Node.js `https` server gave `ERR_EMPTY_RESPONSE` in Chrome and exit 52 in curl. Node logged why:

```
tlsClientError ERR_SSL_HTTP_REQUEST ... error:0A00009C:SSL routines:tls_validate_record_header:http request
```

The identical mistake against a Python `ssl` server produced `ERR_CONNECTION_RESET` instead. Same client error, two different browser messages, depending only on the server software. nginx handles it a third way: it has a non-standard internal code 497 for “a regular request has been sent to the HTTPS port”, which administrators can map to a redirect with `error_page`.

Typical triggers are `http://host:443`, a local dev server that was switched to TLS, a health check pointed at the wrong port, or a proxy URL written with `http://` for a port that only speaks TLS. Check whether the port answers TLS:

```
openssl s_client -connect host:port -servername host </dev/null
```

If a certificate comes back, use `https://`. If the port is meant to be plain HTTP, the service on it is not the one you think.

### 4. A reused keep-alive connection the server had already dropped

This one mostly hits scripts. Our test server answers the first request on each connection with `Connection: keep-alive`, then closes without replying when a second request arrives on that connection. It imitates a server whose idle timeout fires just as the client reuses the socket.

Python requests and httpx raised on the second request every time, with the same errors as in the table above. Chrome loaded `/a`, `/b` and `/c` and got 200 for each. The server log shows why: Chrome hit the dead connection, opened a new one, and resent the request without telling anyone. Chromium’s source states the rule: “we resend a request only if we reused a keep-alive connection.”

RFC 9110 allows exactly this for idempotent methods, which “can be repeated automatically if a communication failure occurs before the client is able to read the server’s response,” and says a client “SHOULD NOT automatically retry a request with a non-idempotent method” without some means of knowing it is safe. So give your script one retry for GET and HEAD. Tested with requests 2.34.2 and urllib3 2.8.0, this recovered all three requests:

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

retry = Retry(total=2, connect=1, read=1, status=0, backoff_factor=0.2,
              allowed_methods=frozenset({"GET", "HEAD", "OPTIONS"}))
s = requests.Session()
s.mount("http://", HTTPAdapter(max_retries=retry))
s.mount("https://", HTTPAdapter(max_retries=retry))
r = s.get("https://example.com/", timeout=10)
```

httpx needs more care. `httpx.HTTPTransport(retries=2)` did not help, because its documentation limits those retries to `httpx.ConnectError` and `httpx.ConnectTimeout`; the second request still raised `RemoteProtocolError`. A manual retry did work, because the pool opens a fresh connection for it:

```
import httpx

def get(client: httpx.Client, url: str) -> httpx.Response:
    try:
        return client.get(url)
    except httpx.RemoteProtocolError:
        return client.get(url)  # idempotent requests only
```

If you run the server, the durable fix is on the timeout pairing. AWS gives the rule for its load balancers: “We also recommend that you configure the idle timeout of your application to be larger than the idle timeout configured for the load balancer.” The same logic applies to any client or proxy that pools connections to you. More on client setup is in [using proxies in Python](/guides/proxies-in-python-requests-httpx/) and [using proxies in Node.js](/guides/proxies-in-nodejs/).

### 5. The proxy closed instead of answering

This is the proxy-specific family, and the result that surprised us most. Chrome reported `ERR_TUNNEL_CONNECTION_FAILED` when Squid answered the [CONNECT](/glossary/http-connect/) with a 503. When a proxy closed without any status line, Chrome reported `ERR_EMPTY_RESPONSE`, for `https://` URLs as well as `http://` ones. Here is every proxy behaviour we tested, side by side with Squid 6.13 configured normally:

| Proxy behaviour | Chrome 155 | curl 8.7.1 |
| --- | --- | --- |
| Closes on missing credentials, http:// URL | ERR_EMPTY_RESPONSE | (52) Empty reply from server |
| Closes on missing credentials, https:// URL | ERR_EMPTY_RESPONSE | (56) Proxy CONNECT aborted |
| Upstream refused, proxy closes, http:// URL | ERR_EMPTY_RESPONSE | (52) Empty reply from server |
| Upstream refused, proxy closes, https:// URL | ERR_EMPTY_RESPONSE | (56) Proxy CONNECT aborted |
| Squid, no credentials sent | ERR_INVALID_AUTH_CREDENTIALS (headless) | (56) CONNECT tunnel failed, response 407 |
| Squid, upstream port closed, https:// URL | ERR_TUNNEL_CONNECTION_FAILED | (56) CONNECT tunnel failed, response 503 |
| Squid, upstream port closed, http:// URL | HTTP 503 page, X-Squid-Error: ERR_CONNECT_FAIL 61 | HTTP/1.1 503 Service Unavailable |
| Squid, origin sent nothing | HTTP 502 page, X-Squid-Error: ERR_ZERO_SIZE_OBJECT 0 | HTTP/1.1 502 Bad Gateway |
| CONNECT answered 200, tunnel closed before TLS | ERR_CONNECTION_CLOSED | (35) LibreSSL SSL_connect: SSL_ERROR_SYSCALL |
| TLS interceptor closes after reading the request | ERR_EMPTY_RESPONSE | (52) Empty reply from server (with -k) |

**Proxy authentication that fails silently.** A proxy is supposed to answer missing or wrong credentials with `407 Proxy Authentication Required` and a `Proxy-Authenticate` header, and Squid did: `Proxy-Authenticate: Basic realm="proxy"`. Our stub proxy closed the connection instead, and every client reported an empty reply. The same stub with `user:pass` returned `ok` to both curl and requests, which proves the path works once the credentials are right. Compare the two runs:

```
curl -sv -o /dev/null -x http://gw.example.net:8000 https://api.ipify.org
curl -sv -o /dev/null -x http://user:pass@gw.example.net:8000 https://api.ipify.org
```

If the first ends in `Proxy CONNECT aborted` and the second succeeds, the problem is credentials or an IP allowlist, not the target. Do not rely on the Python exception class to name the hop. requests raised `ProxyError('Unable to connect to proxy', ...)` for the http:// URL and a plain `ConnectionError` for the https:// URL, against the same proxy failing the same way. A forgotten `HTTPS_PROXY` in the environment can also route a script through a proxy you did not intend; see [HTTP_PROXY, HTTPS_PROXY and NO_PROXY explained](/guides/proxy-environment-variables/). The status codes a proxy should send instead are covered in [403 vs 407 vs 429](/guides/403-vs-407-vs-429/).

**Upstream refusal.** Squid turned every upstream failure into a status code with an explanation header: `ERR_ZERO_SIZE_OBJECT` when the origin sent nothing (its error template reads “Zero Sized Reply. Squid did not receive any data for this request.”), `ERR_READ_ERROR 54` when the origin reset, and `ERR_CONNECT_FAIL 61` when the port was closed. Behind a proxy that behaves like this, an origin’s empty reply never reaches the browser as `ERR_EMPTY_RESPONSE`. You get a 502 page. So when you do see `ERR_EMPTY_RESPONSE` through a proxy, suspect the proxy itself, or the connection between you and it, before the target. Run curl with `-sv -x` and look for any status line or error header the proxy sent. If there is none, take the timestamp to whoever runs the proxy. Our [curl proxy guide](/guides/how-to-use-a-proxy-with-curl/) covers the flags.

**Tunnel opened, then dropped.** When the proxy answered `200 Connection established` and then closed the tunnel before any TLS byte, Chrome said `ERR_CONNECTION_CLOSED`, not `ERR_EMPTY_RESPONSE`, and curl failed inside the TLS handshake with exit 35. That tells you the CONNECT succeeded and the close came from the far side of the tunnel.

**TLS interception.** An intercepting proxy finishes the TLS handshake with your browser using its own certificate, reads the decrypted request, and makes a separate connection to the real site. Antivirus HTTPS scanning, corporate inspection gateways and debugging proxies all work this way (see [TLS interception](/glossary/tls-interception/)). When the interceptor’s own upstream leg fails and it closes your side without writing an error, Chrome reports `ERR_EMPTY_RESPONSE`, even though the connection and the handshake to the interceptor both succeeded. That held whether or not our stub sent a TLS close_notify before closing. A variant that aborted with a reset instead gave `ERR_CONNECTION_RESET` in Chrome and exit 56 in curl. requests reported `ProxyError('Unable to connect to proxy', RemoteDisconnected(...))` in this case, although the CONNECT had in fact worked. The quickest check is who issued the certificate you are being shown:

```
$ openssl s_client -connect curl.se:443 -servername curl.se </dev/null 2>/dev/null | openssl x509 -noout -issuer
issuer=C=US, O=Let's Encrypt, CN=YR2

$ openssl s_client -proxy 127.0.0.1:37193 -connect target.example:443 -servername target.example </dev/null 2>/dev/null | openssl x509 -noout -issuer
issuer=CN=target.example
```

A public certificate authority in the first line is normal. If the issuer names your antivirus product, your employer or a local tool, your traffic is being intercepted, and that software’s log is where the real error is. Excluding the host from inspection, or pausing HTTPS scanning briefly to test, tells you whether it is the cause.

### 6. Something in the browser profile

Extensions that filter or proxy traffic, a system proxy setting, and VPN clients sit on the same path. Test in a throwaway profile with no extensions, for example `google-chrome --user-data-dir=/tmp/clean-profile`, then fetch the same URL with curl from the same machine. If curl works and only your normal Chrome profile fails, the difference lives in that profile.

## Cloudflare sites and the 10xx error codes

On a site behind Cloudflare, your browser connects to Cloudflare’s edge, not to the origin server. Cloudflare documents what happens when the origin hangs up: Error 520 “occurs when the origin server returns an empty, unknown, or unexpected response to Cloudflare,” and the same page, in its section on reading logs, covers the case where the origin “dropped the TCP connection before sending response headers”: Cloudflare then generates the error page itself, “typically a 520 or 500.” The visitor sees that Cloudflare page, not `ERR_EMPTY_RESPONSE`. You can check whether a site is fronted by Cloudflare from the response headers:

```
$ curl -sS -o /dev/null -D - https://proxy.wiki/ | grep -iE '^(server|cf-ray):'
server: cloudflare
cf-ray: <ray id>-<data centre>
```

The 10xx codes are Cloudflare’s own block and configuration pages. A 10xx page is a response, so it never appears together with `ERR_EMPTY_RESPONSE` on the same request. What the common ones mean, in Cloudflare’s words:

| Code | Cloudflare’s description | If you are the visitor | If you run the site |
| --- | --- | --- | --- |
| 1020 | “A security rule with a Block action matched the request.” Returned with HTTP 403. | Send the site owner a screenshot of the error, which carries the Ray ID. | Search Security Events for the Ray ID or client IP, then adjust the rule that matched. |
| 1015 | “You are being rate limited.” | Wait, then try again later. Repeated attempts can extend the block. | Review the rate limiting thresholds and the period they count over. |
| 1010 | The owner “banned your access based on your browser’s signature.” | Notify the site owner. | Browser Integrity Check is controlled in the security settings. |
| 1006, 1007, 1008, 1106 | “Your IP address has been banned.” | Ask the site owner to review their security settings. | Review the rule or allow the visitor’s address. |

Cloudflare’s support pages say plainly that its support staff cannot override a block the site owner configured, so for any of these the path runs through the operator. If Chrome shows `ERR_EMPTY_RESPONSE` on a hostname that answers with `server: cloudflare`, look first at what sits between you and the edge: an interceptor, a proxy or VPN, or an extension. Work through causes 5 and 6.

## Chrome retries before it shows the error

The timings above were longer than the servers’ own failure times, so we recorded a Chrome net-log for one navigation to a server that waits three seconds and then closes. Chrome sent the same GET three times. The log shows two `HTTP_TRANSACTION_RESTART_AFTER_ERROR` events, each with `net_error: ERR_EMPTY_RESPONSE`, before the third attempt failed and the error page appeared, 9,023 ms after the request started. The first attempt used a socket Chrome had opened 17 ms before the request existed. The second used a spare socket it opened while the first attempt was still waiting. The third went out on a connection opened only after the second failure, and once that brand-new connection also came back empty, Chrome stopped. Chromium’s code explains the choice: an empty response “may still be close/reuse race if the socket was preconnected but failed to be used before the server timed it out.”

_Time until Chrome 155 showed the error, against the time the server took to fail. One navigation per row._

| Case | Server fails after (ms) | Chrome shows the error after (ms) |
| --- | --- | --- |
| Server closes at once | — | 58 |
| Node server.timeout 2,000 ms (2 attempts) | 2000 | 4130 |
| Server closes after 3 s (2 attempts) | 3000 | 6030 |
| Same server, net-log run (3 attempts) | 3000 | 9023 |

Each row is a single navigation, and the number of attempts varied between runs (two in one, three in another), so read it as a mechanism rather than a benchmark. Two practical consequences hold either way. A server that dies after N seconds keeps a visitor waiting a multiple of N. And your access log will show the same GET two or three times for one page view, which is Chrome, not the user pressing reload. curl made a single attempt in every case: it failed after 2.0 s against the Node server and 3.0 s against the three-second one.

To capture your own log, open `chrome://net-export`, start logging, reproduce the error in another tab, then stop. Search the file for `ERR_EMPTY_RESPONSE` and look at the socket’s remote address: it tells you whether Chrome was talking to the site, a proxy or a local interceptor.

The retry also affects what you conclude from a server log. A request that appears two or three times, a few seconds apart, from one client is the signature of a handler that dies before responding.

## Cause-to-fix table

| Cause | Chrome | curl | Check | Fix |
| --- | --- | --- | --- | --- |
| Application crashed or timed out | ERR_EMPTY_RESPONSE, often after a delay | (52) | -w '%{time_total}' lands on a round number; server error log | Fix the crash or timeout; add a reverse proxy so failures become 502 |
| Deliberate drop (nginx 444, filter rule) | ERR_EMPTY_RESPONSE, instant | (52) | grep -rn "return 444"; filter logs | Operator changes the rule |
| Plain HTTP to an HTTPS port | ERR_EMPTY_RESPONSE or ERR_CONNECTION_RESET | (52) or (56) | openssl s_client -connect host:port | Use https:// or the right port |
| Stale keep-alive connection | Hidden by Chrome’s automatic retry | — | Fails on the first request after an idle gap, in scripts | Retry idempotent requests once; server idle timeout longer than the client’s |
| Proxy drops on bad credentials | ERR_EMPTY_RESPONSE | (52) http, (56) Proxy CONNECT aborted https | Same request with and without credentials | Correct credentials or IP allowlist |
| Proxy’s upstream refused, proxy closes | ERR_EMPTY_RESPONSE | (52) or (56) Proxy CONNECT aborted | curl -sv -x: no status line from the proxy | Proxy logs or provider support, with the timestamp |
| TLS interceptor drops | ERR_EMPTY_RESPONSE, or ERR_CONNECTION_RESET if it aborts | (52) with -k, (56) on a reset | Certificate issuer is not a public CA | Interceptor log; exclude the host from inspection |
| Extension, VPN or system proxy | ERR_EMPTY_RESPONSE | Usually works | Clean profile vs normal profile | Remove or reconfigure the component |
| Origin behind Cloudflare drops | Cloudflare error page instead, typically 520 | A 520 or 500 status | server: cloudflare, cf-ray headers | Owner checks origin logs for crashes |

## How this was tested

All runs were on 21 October 2026 on macOS (Darwin 25.6.0), with every test server and proxy bound to 127.0.0.1. Clients: Google Chrome 155.0.8059.85 in headless mode driven by playwright-core 1.35.1, 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 Node.js 24.2.0 with undici 7.10.0. Servers: small Python 3.12 socket servers, each failing one way (close with FIN, reset with RST, close after three seconds, drop a reused keep-alive connection, plus a TLS server and a 200 control), stock Node.js `http` and `https` servers, and Squid 6.13 restricted to loopback destinations. The stub proxies close on missing credentials, close after a refused upstream connection, drop the tunnel after a 200, or intercept TLS with a self-signed certificate and then close cleanly or abort with a reset. Chrome ran with `--ignore-certificate-errors` only so the interception case could reach the request stage.

Every case was run at least once per client, and each server logged every request it received, which is how the repeated GETs were counted. A control request to the 200 server succeeded in every client before the failure cases ran. What this does not cover: Firefox and Safari, HTTP/2 and HTTP/3 connections, and any commercial proxy or interception product. The stubs reproduce the behaviours described; they are not models of any particular vendor.

## Frequently asked questions

### What does ERR_EMPTY_RESPONSE mean?

Chrome connected, sent the request, and the other end closed the connection without returning a single byte. Chromium's source defines it as "The server closed the connection without sending any data." It is net error -324.

### Is ERR_EMPTY_RESPONSE caused by my computer or by the website?

It can be either, so first fetch the same URL with curl from the same machine. If curl also prints "curl: (52) Empty reply from server", the site or a proxy on the path is closing the connection. If curl works and only the browser fails, look at extensions, a configured proxy or VPN, and any antivirus HTTPS scanning.

### Does clearing the cache, cookies or DNS fix ERR_EMPTY_RESPONSE?

DNS almost never, because the error only happens after the name resolved and the connection was accepted. Cookies sometimes: Cloudflare lists "Headers exceeding 128 KB (often due to excessive cookies)" among the causes of its 520 error. Node.js 24.2.0's default server answered a 20 KB Cookie header with 431 Request Header Fields Too Large rather than closing, so it depends on the server. A private window sends no cookies and is the quicker test.

### Why do I get ERR_EMPTY_RESPONSE only when using a proxy?

Because the proxy closed the connection without sending a status line. In our tests Chrome showed ERR_EMPTY_RESPONSE when a proxy dropped the connection on missing credentials or after its upstream refused, for http and https URLs alike. A proxy that answers properly sends 407 or 503 instead; headless Chrome reported those as ERR_INVALID_AUTH_CREDENTIALS and, for https URLs, ERR_TUNNEL_CONNECTION_FAILED.

### What is the difference between ERR_EMPTY_RESPONSE, ERR_CONNECTION_RESET and ERR_CONNECTION_CLOSED?

ERR_EMPTY_RESPONSE is an orderly close that delivered zero bytes on a fresh connection. ERR_CONNECTION_RESET corresponds to a TCP RST, an aborted connection. ERR_CONNECTION_CLOSED corresponds to a TCP FIN in other situations; we saw it when a proxy accepted a CONNECT and then closed the tunnel before TLS started.

### Why does curl say "Empty reply from server"?

That is curl exit code 52, which its documentation describes as "Nothing was returned from the server, and under the circumstances, getting nothing is considered an error." It is curl's equivalent of ERR_EMPTY_RESPONSE. Through a proxy with an https URL, curl reports the same failure as "curl: (56) Proxy CONNECT aborted".

## Sources

1. [Chromium source: net_error_list.h (EMPTY_RESPONSE -324, CONNECTION_CLOSED, CONNECTION_RESET)](https://chromium.googlesource.com/chromium/src/+/main/net/base/net_error_list.h)
2. [Chromium source: http_network_transaction.cc (resend after ERR_EMPTY_RESPONSE)](https://chromium.googlesource.com/chromium/src/+/main/net/http/http_network_transaction.cc)
3. [Chromium source: http_stream_parser.cc (when a close becomes ERR_EMPTY_RESPONSE)](https://chromium.googlesource.com/chromium/src/+/main/net/http/http_stream_parser.cc)
4. [Chromium: How to capture a NetLog dump](https://www.chromium.org/for-testers/providing-network-details/)
5. [libcurl error codes (CURLE_GOT_NOTHING 52)](https://curl.se/libcurl/c/libcurl-errors.html)
6. [Python documentation: http.client.RemoteDisconnected](https://docs.python.org/3/library/http.client.html)
7. [HTTPX documentation: transports and retries](https://www.python-httpx.org/advanced/transports/)
8. [Node.js v24 documentation: HTTP (server.timeout)](https://nodejs.org/docs/latest-v24.x/api/http.html)
9. [RFC 9110 section 9.2.2: Idempotent Methods](https://www.rfc-editor.org/rfc/rfc9110.html#section-9.2.2)
10. [RFC 9110 section 9.3.6: CONNECT](https://www.rfc-editor.org/rfc/rfc9110.html#section-9.3.6)
11. [RFC 9110 section 15.5.8: 407 Proxy Authentication Required](https://www.rfc-editor.org/rfc/rfc9110.html#section-15.5.8)
12. [nginx documentation: return directive and code 444](https://nginx.org/en/docs/http/ngx_http_rewrite_module.html#return)
13. [nginx documentation: ngx_http_ssl_module error processing (497)](https://nginx.org/en/docs/http/ngx_http_ssl_module.html#errors)
14. [Squid 6.13 error template: ERR_ZERO_SIZE_OBJECT](https://github.com/squid-cache/squid/blob/SQUID_6_13/errors/templates/ERR_ZERO_SIZE_OBJECT)
15. [AWS: Application Load Balancer connection idle timeout](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/edit-load-balancer-attributes.html#connection-idle-timeout)
16. [Cloudflare: Error 520](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-5xx-errors/error-520/)
17. [Cloudflare: 1xxx errors](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/)
18. [Cloudflare: Error 1020 Access denied](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1020/)
19. [Cloudflare: Error 1015 You are being rate limited](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1015/)
20. [Cloudflare: Error 1010 browser signature](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1010/)
21. [Cloudflare: Errors 1006, 1007, 1008, 1106 IP address banned](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1006/)
