Skip to content
Proxy fundamentals

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.

On this page 8 sections
  1. What each client prints for the same failure
  2. Empty response or reset? Settle that first
  3. Three commands that narrow it down
  4. Causes and how to fix each one
  5. 1. The application died or gave up mid-request
  6. 2. The server closed the connection on purpose
  7. 3. Plain HTTP sent to an HTTPS port
  8. 4. A reused keep-alive connection the server had already dropped
  9. 5. The proxy closed instead of answering
  10. 6. Something in the browser profile
  11. Cloudflare sites and the 10xx error codes
  12. Chrome retries before it shows the error
  13. Cause-to-fix table
  14. How this was tested

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 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

  1. 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.
  2. 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.
  3. 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 and using proxies in Node.js.

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 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. The status codes a proxy should send instead are covered in 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 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). 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. Drawn from the table below. A dash marks a cell with no value; it is not drawn as zero.
Time until Chrome 155 showed the error, against the time the server took to fail. One navigation per row.. Bar chart of Server fails after (ms), Chrome shows the error after (ms) by Case.4 rows, drawn from the table that follows this chart. Cells with no value are shown as a dash and not drawn.Server closes at onceServer closes at once · Server fails after (ms): no value—Server closes at once · Chrome shows the error after (ms): 5858Node server.timeout 2,000 ms (2attempts)Node server.timeout 2,000 ms (2 attempts) · Server fails after (ms): 20002000Node server.timeout 2,000 ms (2 attempts) · Chrome shows the error after (ms): 41304130Server closes after 3 s (2 attempts)Server closes after 3 s (2 attempts) · Server fails after (ms): 30003000Server closes after 3 s (2 attempts) · Chrome shows the error after (ms): 60306030Same server, net-log run (3 attempts)Same server, net-log run (3 attempts) · Server fails after (ms): 30003000Same server, net-log run (3 attempts) · Chrome shows the error after (ms): 9023902305K10K msTime until Chrome 155 showed the error, against the time the server took to fail. One navigation per row.. Bar chart of Server fails after (ms), Chrome shows the error after (ms) by Case.4 rows, drawn from the table that follows this chart. Cells with no value are shown as a dash and not drawn.Server closes at onceServer closes at once · Server fails after (ms): no value—Server closes at once · Chrome shows the error after (ms): 5858Node server.timeout2,000 ms (2 attempts)Node server.timeout 2,000 ms (2 attempts) · Server fails after (ms): 20002000Node server.timeout 2,000 ms (2 attempts) · Chrome shows the error after (ms): 41304130Server closes after 3 s(2 attempts)Server closes after 3 s (2 attempts) · Server fails after (ms): 30003000Server closes after 3 s (2 attempts) · Chrome shows the error after (ms): 60306030Same server, net-log run(3 attempts)Same server, net-log run (3 attempts) · Server fails after (ms): 30003000Same server, net-log run (3 attempts) · Chrome shows the error after (ms): 9023902305K10K ms
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)
  2. Chromium source: http_network_transaction.cc (resend after ERR_EMPTY_RESPONSE)
  3. Chromium source: http_stream_parser.cc (when a close becomes ERR_EMPTY_RESPONSE)
  4. Chromium: How to capture a NetLog dump
  5. libcurl error codes (CURLE_GOT_NOTHING 52)
  6. Python documentation: http.client.RemoteDisconnected
  7. HTTPX documentation: transports and retries
  8. Node.js v24 documentation: HTTP (server.timeout)
  9. RFC 9110 section 9.2.2: Idempotent Methods
  10. RFC 9110 section 9.3.6: CONNECT
  11. RFC 9110 section 15.5.8: 407 Proxy Authentication Required
  12. nginx documentation: return directive and code 444
  13. nginx documentation: ngx_http_ssl_module error processing (497)
  14. Squid 6.13 error template: ERR_ZERO_SIZE_OBJECT
  15. AWS: Application Load Balancer connection idle timeout
  16. Cloudflare: Error 520
  17. Cloudflare: 1xxx errors
  18. Cloudflare: Error 1020 Access denied
  19. Cloudflare: Error 1015 You are being rate limited
  20. Cloudflare: Error 1010 browser signature
  21. Cloudflare: Errors 1006, 1007, 1008, 1106 IP address banned

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