How to fix Error: stdout maxBuffer exceeded in Node.js

Node.jsINTERMEDIATEMEDIUMUpdated Dec 9, 2025· 234 views

The maxBuffer exceeded error occurs when a child process produces more output than the buffer can hold. The default buffer size is 1MB, and when stdout or stderr data exceeds this limit, Node.js terminates the child process and throws an error. This commonly happens when executing commands that produce large amounts of output.

Quick fix

Fixes Error: stdout maxBuffer exceeded

const { spawn } = require('child_process');

// WRONG - buffers all output in memory
const { exec } = require('child_process');
exec('git log --all', (error, stdout) => {
  // May fail with maxBuffer exceeded
  console.log(stdout);
});

// CORRECT - streams output incrementally
const child = spawn('git', ['log', '--all']);

let output = '';
child.stdout.on('data', (data) => {
  output += data.toString();
  // Or process data immediately without accumulating
});

child.stderr.on('data', (data) => {
  console.error(data.toString());
});

child.on('close', (code) => {
  if (code === 0) {
    console.log('Command completed successfully');
    console.log(output);
  } else {
    console.error(`Process exited with code ${code}`);
  }
});
  1. Switch from exec() to spawn() for large output
  2. Increase maxBuffer size if you must use exec()
  3. Pipe spawn() output to a file for very large data
  4. Reduce output verbosity at the source
node.js — error
const { spawn } = require('child_process');
// WRONG - buffers all output in memory
const { exec } = require('child_process');
exec('git log --all', (error, stdout) => {
  // May fail with maxBuffer exceeded
  console.log(stdout);
});
// CORRECT - streams output incrementally
const child = spawn('git', ['log', '--all']);
let output = '';
child.stdout.on('data', (data) => {
  output += data.toString();
  // Or process data immediately without accumulating
});
child.stderr.on('data', (data) => {
  console.error(data.toString());
});
child.on('close', (code) => {
  if (code === 0) {
    console.log('Command completed successfully');
    console.log(output);
  } else {
    console.error(`Process exited with code ${code}`);
  }
});
Error: stdout maxBuffer exceeded

What this error means

When you use child_process.exec() or child_process.execFile() in Node.js, these methods buffer all output from the child process in memory before returning it to you. The maxBuffer option controls the maximum size of this buffer, defaulting to 1MB (1024 * 1024 bytes). If the child process writes more data to stdout or stderr than this limit, Node.js kills the process and throws an "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" error. This is a memory protection mechanism to prevent child processes from consuming unlimited RAM. The error indicates that your command produced too much output for the buffered approach used by exec(), and you need either a larger buffer or a streaming approach.

Typical symptoms

  • Error message "Error: stdout maxBuffer exceeded" or "ERR_CHILD_PROCESS_STDIO_MAXBUFFER"
  • Child process terminates unexpectedly before completing its task
  • Commands that work in terminal fail when run through Node.js exec()
  • Output is truncated and the callback receives an error instead of complete data
  • Large file operations or verbose commands consistently fail in Node.js scripts
  • Build tools or CLI tools with verbose output fail when called from Node.js
  • Git commands with large diffs or npm commands installing many packages fail

Common causes

  1. Using exec() or execFile() to run commands that produce more than 1MB of output to stdout or stderr
  2. Running build commands, compilation processes, or package installations that generate verbose logs
  3. Executing git commands on large repositories that produce extensive diff or log output
  4. Processing large files through command-line tools where output is returned to Node.js
  5. Running database dumps, backups, or exports that output large amounts of data
  6. Using verbose or debug flags on CLI tools without adjusting the buffer size
  7. Collecting test output or logs from long-running processes that exceed the default buffer

How to fix "Error: stdout maxBuffer exceeded"

1Switch from exec() to spawn() for large output

The best solution for handling large output is to use child_process.spawn() instead of exec(). spawn() returns a stream, allowing you to process output incrementally rather than buffering everything in memory. This is the recommended approach for commands with large or unknown output sizes.

javascript
const { spawn } = require('child_process');

// WRONG - buffers all output in memory
const { exec } = require('child_process');
exec('git log --all', (error, stdout) => {
  // May fail with maxBuffer exceeded
  console.log(stdout);
});

// CORRECT - streams output incrementally
const child = spawn('git', ['log', '--all']);

let output = '';
child.stdout.on('data', (data) => {
  output += data.toString();
  // Or process data immediately without accumulating
});

child.stderr.on('data', (data) => {
  console.error(data.toString());
});

child.on('close', (code) => {
  if (code === 0) {
    console.log('Command completed successfully');
    console.log(output);
  } else {
    console.error(`Process exited with code ${code}`);
  }
});
2Increase maxBuffer size if you must use exec()

If you need to use exec() and the command produces predictable output that fits in memory, you can increase the maxBuffer option. However, this is not recommended for very large output as it consumes more RAM. Set maxBuffer to a value larger than your expected output size.

javascript
const { exec } = require('child_process');

// Increase buffer to 10MB
exec('npm install', { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
  if (error) {
    console.error(`Error: ${error.message}`);
    return;
  }
  console.log(stdout);
});

Note: This approach still buffers all output in memory, so it's not suitable for very large outputs or when output size is unknown.

3Pipe spawn() output to a file for very large data

For extremely large output that you don't need to process in Node.js, pipe the child process output directly to a file. This avoids buffering in memory entirely.

javascript
const { spawn } = require('child_process');
const fs = require('fs');

const child = spawn('docker', ['logs', 'my-container']);
const logFile = fs.createWriteStream('container-logs.txt');

child.stdout.pipe(logFile);
child.stderr.pipe(logFile);

child.on('close', (code) => {
  console.log(`Logs written to file. Exit code: ${code}`);
  logFile.end();
});
4Reduce output verbosity at the source

If possible, modify the command to produce less output. Use quiet flags, disable verbose logging, or filter output to only what you need. This is often the most efficient solution.

javascript
const { exec } = require('child_process');

// Add flags to reduce output
exec('npm install --silent', (error, stdout, stderr) => {
  // Less output, less likely to exceed buffer
  console.log(stdout);
});

// Or filter git log output
exec('git log --oneline --max-count=100', (error, stdout) => {
  // Limited output instead of entire history
  console.log(stdout);
});
5Process data incrementally with spawn() data events

For real-time processing or when you need to react to output as it arrives, handle data events directly without accumulating all output. This is ideal for monitoring progress, parsing logs, or extracting specific information.

javascript
const { spawn } = require('child_process');

const child = spawn('npm', ['test']);

child.stdout.on('data', (data) => {
  // Process each chunk immediately
  const lines = data.toString().split('\n');
  lines.forEach(line => {
    if (line.includes('PASS') || line.includes('FAIL')) {
      console.log(line);
    }
  });
});

child.on('close', (code) => {
  console.log(`Tests completed with exit code ${code}`);
});

Advanced notes

The fundamental difference between exec() and spawn() is that exec() buffers the entire output before calling the callback, while spawn() provides streaming access to output as it's produced. exec() is built on top of spawn() but adds the buffering layer for convenience. For most production use cases involving external commands, spawn() is the better choice. The default maxBuffer of 1MB was chosen as a reasonable balance between memory usage and typical command output sizes, but modern applications often need to handle larger outputs. When using spawn() with streaming, be careful about backpressure - if you're writing to a slow destination (like a network stream), the child process may pause if Node.js can't keep up with the output rate. The maxBuffer option applies to both stdout and stderr combined, so verbose error output can also trigger this limit. In some cases, you can redirect stderr to stdout in the command itself (using shell redirection) or handle them separately with different buffer sizes. For TypeScript users, ensure you properly type the data parameter in event handlers as Buffer rather than string. When debugging maxBuffer issues, use console.error() to output error messages and check if stderr is contributing to the buffer overflow.

Frequently asked questions

What does "Error: stdout maxBuffer exceeded" mean?
js, these methods buffer all output from the child process in memory before returning it to you. The maxBuffer option controls the maximum size of this buffer, defaulting to 1MB (1024 * 1024 bytes). js kills the process and throws an "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" error.
How do I fix "Error: stdout maxBuffer exceeded"?
The maxBuffer exceeded error occurs when a child process produces more output than the buffer can hold. The default buffer size is 1MB, and when stdout or stderr data exceeds this limit, Node.js terminates the child process and throws an error. This commonly happens when executing commands that produce large amounts of output.
What causes "Error: stdout maxBuffer exceeded"?
Using exec() or execFile() to run commands that produce more than 1MB of output to stdout or stderr Running build commands, compilation processes, or package installations that generate verbose logs Executing git commands on large repositories that produce extensive diff or log output
Is the "Error: stdout maxBuffer exceeded" error serious?
It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Official resources & further reading