Stream Large Responses from Express with Node.js Streams (2026)

Express is actually a thin wrapper around Node.js’s http module, and when you’re dealing with large responses, the most efficient way to serve them is by leveraging Node.js’s built-in Streams API, not by trying to buffer the entire response in memory.

Consider this scenario: a user requests a massive CSV file generated on the fly by your Express application.

const express = require('express');
const app = express();
const port = 3000;

// A hypothetical function that generates a large stream of data
function generateLargeCSVStream() {
  const { Readable } = require('stream');
  let rowCount = 0;
  const maxRows = 1000000; // 1 million rows

  return new Readable({
    objectMode: false, // We're dealing with strings (CSV lines)
    read() {
      if (rowCount < maxRows) {
        const headers = rowCount === 0 ? 'id,name,value\n' : '';
        const line = `${headers}${rowCount},Item ${rowCount},${Math.random() * 100}\n`;
        this.push(line);
        rowCount++;
      } else {
        this.push(null); // Signal end of stream
      }
    }
  });
}

app.get('/large-csv', (req, res) => {
  res.setHeader('Content-Type', 'text/csv');
  res.setHeader('Content-Disposition', 'attachment; filename="large_data.csv"');

  const csvStream = generateLargeCSVStream();
  csvStream.pipe(res); // Pipe the readable stream directly to the writable response stream
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

Here’s what’s happening under the hood:

1. Readable Stream Creation: We define a Readable stream. Its read() method is called by Node.js whenever the stream is ready to emit more data. Inside read(), we push data chunks (CSV lines in this case) using this.push(). When there’s no more data, we signal the end by pushing null.
2. res as a Writable Stream: Express’s response object (res) is a Writable stream. It’s designed to accept data chunks and send them to the client over the HTTP connection.
3. pipe() Magic: The .pipe() method is the core of stream composition. csvStream.pipe(res) tells Node.js to take data from csvStream as it becomes available and write it directly to res. This means data flows from the generator to the client without ever being fully stored in memory.
4. Headers for Downloads: Content-Type: text/csv tells the browser how to interpret the data. Content-Disposition: attachment; filename="large_data.csv" suggests the browser should download the response as a file named large_data.csv.

The mental model for streams is about producers and consumers. Your generateLargeCSVStream is a producer, and res is a consumer. pipe() connects them. The "backpressure" mechanism is crucial here: if the consumer (the client or the network) can’t keep up with the producer, the producer will automatically slow down to avoid overwhelming the system. This is handled implicitly by pipe().

When you’re streaming, you’re not just sending data; you’re orchestrating a flow. The Readable stream is the source, and the Writable stream is the destination. The pipe() method is the conveyor belt that moves data efficiently between them. You control the rate of data production in the Readable stream’s read() method and the format of the data by what you push().

Many developers think of res.send() or res.json(). These methods are designed for smaller payloads because they buffer the entire response body in memory before sending it. When you hit large responses, you’re essentially asking Node.js to hold gigabytes of data in RAM, which will inevitably lead to JavaScript heap out of memory errors or a sluggish, unresponsive server. Streams bypass this by processing data in chunks.

A common mistake is to forget to call this.push(null) when the stream is exhausted. This will cause the client to hang indefinitely, waiting for the rest of the response.

The next concept you’ll want to explore is combining multiple streams, for example, using the pipeline utility from the stream module for more robust error handling and automatic stream cleanup.