On this page 8 sections
- What each client prints for the same failure
- Empty response or reset? Settle that first
- Three commands that narrow it down
- Causes and how to fix each one
- 1. The application died or gave up mid-request
- 2. The server closed the connection on purpose
- 3. Plain HTTP sent to an HTTPS port
- 4. A reused keep-alive connection the server had already dropped
- 5. The proxy closed instead of answering
- 6. Something in the browser profile
- Cloudflare sites and the 10xx error codes
- Chrome retries before it shows the error
- Cause-to-fix table
- 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
- 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 asHTTP/1.1 407or503; one that hangs up printsProxy CONNECT aborted. - If it is HTTPS: check who issued the certificate (the
opensslcommand 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.”
| 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.
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?
Is ERR_EMPTY_RESPONSE caused by my computer or by the website?
Does clearing the cache, cookies or DNS fix ERR_EMPTY_RESPONSE?
Why do I get ERR_EMPTY_RESPONSE only when using a proxy?
What is the difference between ERR_EMPTY_RESPONSE, ERR_CONNECTION_RESET and ERR_CONNECTION_CLOSED?
Why does curl say "Empty reply from server"?
Sources
- Chromium source: net_error_list.h (EMPTY_RESPONSE -324, CONNECTION_CLOSED, CONNECTION_RESET)
- Chromium source: http_network_transaction.cc (resend after ERR_EMPTY_RESPONSE)
- Chromium source: http_stream_parser.cc (when a close becomes ERR_EMPTY_RESPONSE)
- Chromium: How to capture a NetLog dump
- libcurl error codes (CURLE_GOT_NOTHING 52)
- Python documentation: http.client.RemoteDisconnected
- HTTPX documentation: transports and retries
- Node.js v24 documentation: HTTP (server.timeout)
- RFC 9110 section 9.2.2: Idempotent Methods
- RFC 9110 section 9.3.6: CONNECT
- RFC 9110 section 15.5.8: 407 Proxy Authentication Required
- nginx documentation: return directive and code 444
- nginx documentation: ngx_http_ssl_module error processing (497)
- Squid 6.13 error template: ERR_ZERO_SIZE_OBJECT
- AWS: Application Load Balancer connection idle timeout
- Cloudflare: Error 520
- Cloudflare: 1xxx errors
- Cloudflare: Error 1020 Access denied
- Cloudflare: Error 1015 You are being rate limited
- Cloudflare: Error 1010 browser signature
- Cloudflare: Errors 1006, 1007, 1008, 1106 IP address banned