Error: read ECONNRESET

What is ECONNRESET?

ECONNRESET stands for Error CONNection RESET — a POSIX system error thrown when the remote end of a TCP connection sends a RST packet, abruptly terminating the socket. Unlike a graceful close (FIN), a reset discards any data in flight and gives the local side no chance to finish reading or writing.

Node.js surfaces this as an Error object with code: 'ECONNRESET' on HTTP requests, raw net.Socket streams, database connections, and any other TCP-based API. At the HTTP layer it also appears as Error: socket hang up — both errors share the same root cause.

Full Error Example

Error: read ECONNRESET
    at TLSWrap.onStreamRead (node:internal/stream_base_commons:217:20)
    at TLSWrap.callbackTrampoline (node:internal/async_hooks:130:17) {
  errno: -104,
  code: 'ECONNRESET',
  syscall: 'read'
}

Error: socket hang up
    at connResetException (node:internal/errors:711:14)
    at Socket.socketOnEnd (node:_http_client:518:23)
    at Socket.emit (node:events:529:35) {
  code: 'ECONNRESET'
}

The syscall field tells you which operation was interrupted: 'read' (receiving data), 'write' (sending data), or 'connect' (initial handshake). This narrows down whether the problem is during connection establishment or mid-transfer. The socket hang up variant does not expose a syscall but always carries code: 'ECONNRESET'.

Common Causes

Fix 1 – Retry on ECONNRESET (keep-alive race condition)

The most common cause is a race between the server closing a keep-alive socket and Node.js reusing it from the pool. The fix is to catch ECONNRESET and retry the request once with a fresh socket.

async function fetchWithRetry(url, options = {}, retries = 1) {
  try {
    return await fetch(url, options);
  } catch (err) {
    if (err.code === 'ECONNRESET' && retries > 0) {
      console.warn('ECONNRESET – retrying request...');
      return fetchWithRetry(url, options, retries - 1);
    }
    throw err;
  }
}

// Usage
const res = await fetchWithRetry('https://api.example.com/data');
const data = await res.json();

Fix 2 – Retry with exponential backoff

For production code making many outbound requests, use a full retry strategy that handles transient network errors and backs off to avoid overwhelming the server.

const RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ENOTFOUND']);

async function fetchWithBackoff(url, options = {}, { retries = 3, baseDelayMs = 200 } = {}) {
  for (let attempt = 0; attempt <= retries; attempt++) {
    try {
      const res = await fetch(url, options);
      if (res.ok) return res;
      // Retry on 5xx server errors
      if (res.status >= 500 && attempt < retries) {
        await sleep(baseDelayMs * 2 ** attempt);
        continue;
      }
      return res; // Return non-retryable HTTP errors as-is
    } catch (err) {
      if (RETRYABLE_CODES.has(err.code) && attempt < retries) {
        await sleep(baseDelayMs * 2 ** attempt);
        continue;
      }
      throw err;
    }
  }
}

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

Fix 3 – Set a socket timeout

Without a timeout, a connection reset mid-response can leave your code waiting indefinitely. Set AbortSignal.timeout() (Node.js 17.3+) or a manual timeout on the socket to fail fast.

// Using AbortSignal.timeout (Node.js 17.3+, recommended)
const res = await fetch('https://api.example.com/data', {
  signal: AbortSignal.timeout(5000), // 5 second total timeout
});

// Using http/https request timeout (older Node.js)
const http = require('http');

const req = http.get('http://api.example.com/data', (res) => {
  res.resume(); // consume the response
});

req.setTimeout(5000, () => {
  req.destroy(new Error('Request timed out'));
});

req.on('error', (err) => {
  if (err.code === 'ECONNRESET' || err.message === 'Request timed out') {
    console.error('Request failed:', err.message);
  }
});

Fix 4 – Handle ECONNRESET on keep-alive agents

When using a custom http.Agent with keepAlive: true, attach an error listener to the socket to prevent unhandled errors from crashing the process when idle sockets are reset.

const http = require('http');

const agent = new http.Agent({ keepAlive: true });

function request(options) {
  return new Promise((resolve, reject) => {
    const req = http.request({ ...options, agent }, resolve);

    req.on('socket', (socket) => {
      socket.on('error', (err) => {
        if (err.code === 'ECONNRESET') {
          // Socket was reset; retry without keep-alive
          req.destroy();
          http.request({ ...options, agent: false }, resolve).end();
        }
      });
    });

    req.on('error', (err) => {
      if (err.code === 'ECONNRESET') {
        // Retry once with a new connection
        http.request({ ...options, agent: false }, resolve)
          .on('error', reject)
          .end();
      } else {
        reject(err);
      }
    });

    req.end();
  });
}

Fix 5 – Tune keep-alive timeouts (Node.js 19+ / AWS ALB)

If you control the server, set its keep-alive timeout to be longer than your load balancer's idle timeout. This prevents the server from closing sockets that the load balancer still considers open. This is especially important in Node.js 19+ where keepAliveTimeout defaults to only 5 seconds.

const http = require('http');
const app = require('./app'); // your Express/Fastify app

const server = http.createServer(app);

// Set server keep-alive timeout longer than your load balancer's idle timeout.
// AWS ALB default idle timeout is 60 s — set this to 65 s or higher.
server.keepAliveTimeout = 65_000;
server.headersTimeout = 66_000; // must be > keepAliveTimeout

server.listen(3000);

Fix 6 – Axios retry interceptor and agent tuning

When using axios, configure the HTTP agent's freeSocketTimeout to be shorter than the server's keep-alive timeout so stale sockets are discarded before reuse. Add a request interceptor to retry on ECONNRESET.

const axios = require('axios');
const http = require('http');
const https = require('https');

// Agents with freeSocketTimeout shorter than server keepAliveTimeout
const httpAgent  = new http.Agent({ keepAlive: true, freeSocketTimeout: 4000 });
const httpsAgent = new https.Agent({ keepAlive: true, freeSocketTimeout: 4000 });

const client = axios.create({ httpAgent, httpsAgent });

// Retry interceptor
client.interceptors.response.use(undefined, async (err) => {
  const config = err.config;
  if (!config) throw err;

  config._retryCount = (config._retryCount || 0) + 1;

  if (err.code === 'ECONNRESET' && config._retryCount <= 3) {
    const delay = 200 * 2 ** (config._retryCount - 1); // exponential backoff
    await new Promise((r) => setTimeout(r, delay));
    return client(config);
  }

  throw err;
});

// Usage
const { data } = await client.get('https://api.example.com/data');

Fix 7 – Database connection pool ECONNRESET (MySQL, PostgreSQL, MongoDB)

Database drivers reuse pooled connections. If a firewall or the database server closes an idle pooled socket, the next query receives ECONNRESET. Enable TCP keep-alive on pool connections and configure reconnection.

MySQL2

const mysql = require('mysql2/promise');

const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  database: 'mydb',
  waitForConnections: true,
  connectionLimit: 10,
  enableKeepAlive: true,          // send TCP keep-alive packets
  keepAliveInitialDelay: 10000,   // start keep-alives after 10 s of idle
});

// Handle pool-level errors (prevents unhandled ECONNRESET crashes)
pool.on('error', (err) => {
  console.error('MySQL pool error:', err.code, err.message);
});

PostgreSQL (pg)

const { Pool } = require('pg');

const pool = new Pool({
  host: 'localhost',
  database: 'mydb',
  keepAlives: true,               // enable TCP keep-alives
  keepAlivesInitialDelay: 10,     // seconds before first keep-alive probe
  connectionTimeoutMillis: 5000,
  idleTimeoutMillis: 30000,       // release idle connections before firewall kills them
});

pool.on('error', (err) => {
  console.error('PostgreSQL pool error:', err.code);
});

MongoDB (Mongoose)

const mongoose = require('mongoose');

await mongoose.connect('mongodb://localhost:27017/mydb', {
  socketTimeoutMS: 45000,         // give up queries after 45 s
  heartbeatFrequencyMS: 10000,    // monitor server health every 10 s
  serverSelectionTimeoutMS: 5000, // fail fast if no server reachable
});

Fix 8 – Handle ECONNRESET on streams

When piping or reading from an HTTP response stream, a connection reset causes an 'error' event on the stream. Always attach an error handler.

const https = require('https');
const fs = require('fs');

https.get('https://example.com/large-file.zip', (res) => {
  const out = fs.createWriteStream('file.zip');

  res.on('error', (err) => {
    if (err.code === 'ECONNRESET') {
      console.error('Download interrupted, retry logic here');
      out.close();
    }
  });

  res.pipe(out);
}).on('error', (err) => {
  console.error('Request error:', err.code, err.message);
});

Fix 9 – Disable keep-alive (Node.js 19+ test environments)

In test environments where connections are expected to close immediately, the Node.js 19+ default keep-alive causes unexpected ECONNRESET errors. Disable it explicitly:

const http = require('http');

// Option A: disable keep-alive on server creation
const server = http.createServer({ keepAlive: false }, app);

// Option B: send Connection: close header on each response
app.use((req, res, next) => {
  res.setHeader('Connection', 'close');
  next();
});

Fix 10 – Circuit breaker for repeated ECONNRESET

When a remote service is persistently unreachable or resetting, a circuit breaker prevents cascading failures by stopping requests after a failure threshold is reached.

class CircuitBreaker {
  constructor(threshold = 5, resetAfterMs = 30_000) {
    this.failures  = 0;
    this.threshold = threshold;
    this.state     = 'closed'; // closed = normal, open = blocking requests
    this.resetAfterMs = resetAfterMs;
  }

  async call(fn) {
    if (this.state === 'open') {
      throw new Error('Circuit breaker is open — service unavailable');
    }
    try {
      const result = await fn();
      this.failures = 0; // reset on success
      return result;
    } catch (err) {
      if (err.code === 'ECONNRESET' || err.code === 'ECONNREFUSED') {
        this.failures++;
        if (this.failures >= this.threshold) {
          this.state = 'open';
          setTimeout(() => {
            this.state  = 'closed';
            this.failures = 0;
          }, this.resetAfterMs);
        }
      }
      throw err;
    }
  }
}

const breaker = new CircuitBreaker();
const data = await breaker.call(() => fetch('https://api.example.com/data'));

Debugging Checklist

1. Check err.syscall: 'read' = reset while receiving, 'write' = reset while sending, 'connect' = reset during handshake.
2. Check server logs for crashes, OOM kills, or intentional connection limits around the time of the error.
3. Verify your keepAliveTimeout is higher than your load balancer's idle timeout (AWS ALB: 60 s).
4. Confirm server.maxConnections is not set to a value too low for your traffic.
5. If using a proxy or VPN, check whether it enforces connection time limits.
6. Enable NODE_DEBUG=net,http to trace socket lifecycle events and see exactly when the reset occurs.
7. Use tcpdump or Wireshark to confirm a RST packet is actually arriving from the remote host.
8. For database ECONNRESET: check the database server's wait_timeout (MySQL) or tcp_keepalives_idle (PostgreSQL) settings.

# Enable Node.js network debug output
NODE_DEBUG=net,http node app.js 2>&1 | grep -E "(ECONNRESET|RST|socket)"

Frequently Asked Questions

Related Errors

• EADDRINUSE: address already in use — port conflict when starting a server
• ECONNREFUSED: connection refused — nothing is listening on the target port; the connection was never established
• ETIMEDOUT: connection timed out — no response within the timeout window; the connection was not actively reset
• ENOTFOUND: getaddrinfo ENOTFOUND — DNS resolution failed before a TCP connection could be made
• EPIPE: broken pipe — write to a socket whose read end has already closed; often accompanies ECONNRESET on the write path
• EMFILE: too many open files — file descriptor exhaustion can prevent new sockets from being opened after ECONNRESET failures accumulate
• HPE_INVALID_EOF_STATE — HTTP parser received unexpected EOF, often seen alongside ECONNRESET on truncated responses