How to fix Error: EPIPE: broken pipe (write to closed stream) in Node.js

Node.jsINTERMEDIATEMEDIUMUpdated Dec 9, 2025· 432 views

This error occurs when Node.js attempts to write data to a stream, pipe, or socket that has already been closed by the receiving end. It's a POSIX error indicating the connection was terminated before all data could be transmitted.

Quick fix

Fixes EPIPE

const stream = getWritableStream();

stream.on('error', (err) => {
  if (err.code === 'EPIPE') {
    console.log('Client disconnected, stream closed');
    // Clean up resources, don't crash
  } else {
    console.error('Stream error:', err);
  }
});

stream.write(data);
  1. Add error handlers to all streams and sockets
  2. Check stream state before writing
  3. Use stream.pipeline() for better error handling
  4. Handle client disconnection in HTTP servers
node.js — error
const stream = getWritableStream();
stream.on('error', (err) => {
  if (err.code === 'EPIPE') {
    console.log('Client disconnected, stream closed');
    // Clean up resources, don't crash
  } else {
    console.error('Stream error:', err);
  }
});
stream.write(data);
Error: EPIPE: broken pipe (write to closed stream)

What this error means

The EPIPE error (Error: Pipe) is a POSIX system error that indicates a "broken pipe" condition. In Node.js, this occurs when your application tries to write data to a stream, socket, or pipe that has been closed or terminated on the receiving end. This typically happens in scenarios involving HTTP responses, socket connections, or piped streams where the consumer (client, process, or downstream stream) has disconnected or closed the connection before your application finished writing data. The operating system detects that there's no longer a receiver for the data and raises an EPIPE error. Common contexts include HTTP servers where clients disconnect mid-response, child processes that terminate unexpectedly, or stream pipelines where downstream consumers close prematurely. The error is Node.js's way of signaling that the communication channel has broken down.

Typical symptoms

  • Application crashes with "Error: EPIPE: broken pipe" when writing to streams
  • HTTP server throws unhandled errors when clients disconnect early
  • Socket.IO or WebSocket connections fail with broken pipe errors
  • Child process communication fails with EPIPE when writing to stdin
  • Stream pipelines crash when piping to closed or ended streams
  • Error occurs specifically during write operations, not reads
  • More frequent under high load or with slow network connections

Common causes

  1. Client disconnects HTTP connection before server finishes sending response
  2. Writing to a socket after it has been closed or ended
  3. Downstream stream in a pipeline closes before upstream finishes writing
  4. Child process exits or crashes while parent is writing to its stdin
  5. Network timeout causes connection to close during data transmission
  6. Client cancels long-running request or file download mid-transfer
  7. Stream buffer overflow causes premature stream termination
  8. Missing error handlers allow streams to close unexpectedly

How to fix "Error: EPIPE: broken pipe (write to closed stream)"

1Add error handlers to all streams and sockets

Attach error event listeners to catch EPIPE errors gracefully instead of letting them crash your application:

javascript
const stream = getWritableStream();

stream.on('error', (err) => {
  if (err.code === 'EPIPE') {
    console.log('Client disconnected, stream closed');
    // Clean up resources, don't crash
  } else {
    console.error('Stream error:', err);
  }
});

stream.write(data);

For HTTP responses:

javascript
app.get('/data', (req, res) => {
  res.on('error', (err) => {
    if (err.code === 'EPIPE') {
      console.log('Client disconnected');
    }
  });

  // Send response data
  res.write(largeData);
});
2Check stream state before writing

Verify that streams are still writable before attempting to write data:

javascript
function safeWrite(stream, data) {
  if (!stream.destroyed && stream.writable) {
    stream.write(data, (err) => {
      if (err && err.code === 'EPIPE') {
        console.log('Stream closed, stopping writes');
      }
    });
  } else {
    console.log('Stream not writable, skipping write');
  }
}

For HTTP responses, check if the connection is still open:

javascript
app.get('/stream', (req, res) => {
  const interval = setInterval(() => {
    if (res.writableEnded || !res.writable) {
      console.log('Response stream closed');
      clearInterval(interval);
      return;
    }

    res.write(`data: ${new Date().toISOString()}\n\n`);
  }, 1000);

  req.on('close', () => {
    clearInterval(interval);
  });
});
3Use stream.pipeline() for better error handling

Replace manual piping with stream.pipeline() which provides automatic error propagation and cleanup:

javascript
const { pipeline } = require('stream');
const fs = require('fs');

// Old approach (error-prone):
// readStream.pipe(writeStream);

// Better approach:
pipeline(
  fs.createReadStream('input.txt'),
  transformStream,
  fs.createWriteStream('output.txt'),
  (err) => {
    if (err) {
      if (err.code === 'EPIPE') {
        console.log('Stream closed prematurely');
      } else {
        console.error('Pipeline error:', err);
      }
    } else {
      console.log('Pipeline completed successfully');
    }
  }
);

For HTTP file downloads:

javascript
const { pipeline } = require('stream');
const fs = require('fs');

app.get('/download', (req, res) => {
  const fileStream = fs.createReadStream('large-file.zip');

  pipeline(fileStream, res, (err) => {
    if (err && err.code === 'EPIPE') {
      console.log('Client disconnected during download');
    }
  });
});
4Handle client disconnection in HTTP servers

Monitor the request object for early disconnection and stop processing:

javascript
app.get('/expensive-operation', async (req, res) => {
  let clientDisconnected = false;

  req.on('close', () => {
    clientDisconnected = true;
    console.log('Client disconnected, aborting operation');
  });

  res.on('error', (err) => {
    if (err.code === 'EPIPE') {
      console.log('Broken pipe, client disconnected');
    }
  });

  for (let i = 0; i < 1000; i++) {
    if (clientDisconnected) {
      break; // Stop processing
    }

    const data = await expensiveOperation(i);

    if (!res.writableEnded) {
      res.write(data);
    }
  }

  if (!clientDisconnected) {
    res.end();
  }
});
5Add timeout handling for long-running operations

Implement timeouts to prevent indefinite stream operations that increase EPIPE risk:

javascript
const http = require('http');

const server = http.createServer((req, res) => {
  // Set socket timeout
  req.socket.setTimeout(30000); // 30 seconds

  req.socket.on('timeout', () => {
    console.log('Socket timeout, closing connection');
    req.socket.destroy();
  });

  res.on('error', (err) => {
    if (err.code === 'EPIPE') {
      console.log('Client disconnected');
    }
  });

  // Handle request...
});

For streams with backpressure:

javascript
function writeWithBackpressure(stream, data) {
  return new Promise((resolve, reject) => {
    if (!stream.writable || stream.destroyed) {
      reject(new Error('Stream not writable'));
      return;
    }

    const canContinue = stream.write(data);

    if (canContinue) {
      resolve();
    } else {
      stream.once('drain', resolve);
      stream.once('error', reject);
    }
  });
}

Advanced notes

Stream Error Propagation: In Node.js, error events do not automatically propagate through piped streams. If a downstream stream emits an error, the upstream stream won't know about it unless you manually handle it. This is why stream.pipeline() is recommended—it handles error propagation and cleanup automatically.

Socket Keep-Alive: For HTTP servers, enabling keep-alive can help detect closed connections earlier. Set server.keepAliveTimeout and monitor connection state to catch disconnections before attempting writes.

Graceful Degradation: In production systems, EPIPE errors are often normal—clients disconnect, requests timeout, or networks fail. Design your application to treat EPIPE as an expected condition rather than a critical error. Log it for monitoring but don't crash the process.

Child Process Communication: When using child_process.spawn() or fork(), always handle both the child's exit event and the stdin stream's error event. Children can terminate unexpectedly, leaving parent processes with broken pipes when writing to stdin.

Clustering and Worker Processes: In clustered Node.js applications, EPIPE errors can occur when workers restart or die while handling requests. Implement health checks and graceful shutdown procedures to minimize these occurrences.

Debugging Tips: To identify which stream is causing EPIPE errors, add unique identifiers to your streams and log them in error handlers. Use process.on('uncaughtException') temporarily during debugging to catch unhandled EPIPE errors and trace their origin.

Performance Considerations: Checking stream state before every write operation adds minimal overhead but significantly improves reliability. For high-throughput applications, batch these checks or implement circuit breakers that pause writes after detecting multiple EPIPE errors.

Frequently asked questions

What does "EPIPE" mean?
The EPIPE error (Error: Pipe) is a POSIX system error that indicates a "broken pipe" condition. js, this occurs when your application tries to write data to a stream, socket, or pipe that has been closed or terminated on the receiving end. This typically happens in scenarios involving HTTP responses, socket connections, or piped streams where the consumer (client, process, or downstream stream) has disconnected or closed the connection before your application finished writing data.
How do I fix "EPIPE"?
This error occurs when Node.js attempts to write data to a stream, pipe, or socket that has already been closed by the receiving end. It's a POSIX error indicating the connection was terminated before all data could be transmitted.
What causes "EPIPE"?
Client disconnects HTTP connection before server finishes sending response Writing to a socket after it has been closed or ended Downstream stream in a pipeline closes before upstream finishes writing
Is the "EPIPE" error serious?
It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Official resources & further reading