How to fix FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory in Node.js

Node.jsINTERMEDIATEHIGH

This fatal error occurs when Node.js runs out of memory trying to allocate space in the JavaScript heap. It typically happens when processing large datasets, running memory-intensive operations, or when there are memory leaks that gradually consume all available heap space.

What this error means

This error is thrown by the V8 JavaScript engine when Node.js attempts to allocate more memory than is available in the heap. The "CALL_AND_RETRY_LAST" message indicates that V8 has exhausted all attempts to free up memory through garbage collection and failed to satisfy the memory allocation request. Node.js has a default memory limit (approximately 512 MB for 32-bit systems and 1.4-2 GB for 64-bit systems) to prevent runaway processes from consuming all system resources. When your application exceeds this limit, the process terminates with this fatal error. The heap is where V8 stores objects, strings, and closures. The Old Space within the heap is where long-lived objects are stored, and this is the area controlled by the --max-old-space-size flag. When the Old Space fills up and garbage collection cannot free enough memory, the allocation fails and this error occurs.

How to fix "FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory"

1Increase heap size using --max-old-space-size flag

The quickest solution is to increase the memory limit for Node.js. Run your script with the --max-old-space-size flag:

bash

node --max-old-space-size=4096 your-script.js

The value is in megabytes. Common values:
- 2048 (2 GB) - for moderate workloads
- 4096 (4 GB) - for large applications
- 8192 (8 GB) - for very large builds or data processing

For npm scripts, modify your package.json:

json

{
  "scripts": {
    "build": "node --max-old-space-size=4096 node_modules/webpack/bin/webpack.js",
    "start": "node --max-old-space-size=4096 server.js"
  }
}

Note: On a machine with 2 GB of RAM, don't exceed 1.5 GB to leave memory for the OS and other processes.

2Set NODE_OPTIONS environment variable

For a persistent solution across all Node.js processes, set the NODE_OPTIONS environment variable:

Linux/macOS:

bash

export NODE_OPTIONS="--max-old-space-size=4096"
node your-script.js

Add to ~/.bashrc or ~/.zshrc for permanent effect:

bash

echo 'export NODE_OPTIONS="--max-old-space-size=4096"' >> ~/.bashrc

Windows (Command Prompt):

cmd

set NODE_OPTIONS=--max-old-space-size=4096
node your-script.js

Windows (PowerShell):

powershell

$env:NODE_OPTIONS="--max-old-space-size=4096"
node your-script.js

For CI/CD environments, add NODE_OPTIONS to your environment configuration.

3Identify and fix memory leaks

If increasing memory only delays the error, you likely have a memory leak. Use profiling tools to identify it:

Using Chrome DevTools:

bash

node --inspect your-script.js

Open chrome://inspect in Chrome, click "inspect", and use the Memory tab to take heap snapshots.

Using clinic.js:

bash

npm install -g clinic
clinic doctor -- node your-script.js

Common leak patterns to check:
- Event listeners not removed: Always call .removeListener() or .off()
- Timers not cleared: Use clearInterval() and clearTimeout()
- Global variables accumulating data
- Closures holding references to large objects
- Cache implementations without size limits

4Use streaming for large data processing

Instead of loading entire files into memory, use streams to process data incrementally:

Bad - Loads entire file:

javascript

const fs = require('fs');
const data = fs.readFileSync('large-file.json', 'utf8');
const parsed = JSON.parse(data); // All in memory

Good - Streams data:

javascript

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

const stream = fs.createReadStream('large-file.txt');
const rl = readline.createInterface({
  input: stream,
  crlfDelay: Infinity
});

for await (const line of rl) {
  // Process one line at a time
  processLine(line);
}

For JSON, use streaming JSON parsers like stream-json:

javascript

const { parser } = require('stream-json');
const { streamArray } = require('stream-json/streamers/StreamArray');

fs.createReadStream('large.json')
  .pipe(parser())
  .pipe(streamArray())
  .on('data', ({ value }) => {
    // Process one object at a time
  });

5Optimize data structures and algorithms

Review your code for inefficient patterns:

Avoid creating unnecessary copies:

javascript

// Bad - creates multiple intermediate arrays
const result = data
  .map(x => transform1(x))
  .map(x => transform2(x))
  .filter(x => x.valid);

// Better - single pass
const result = data.reduce((acc, x) => {
  const t1 = transform1(x);
  const t2 = transform2(t1);
  if (t2.valid) acc.push(t2);
  return acc;
}, []);

Release large objects when done:

javascript

let largeBuffer = Buffer.alloc(100 * 1024 * 1024);
// ... use buffer ...
largeBuffer = null; // Explicitly release for garbage collection

Implement cache size limits:

javascript

const cache = new Map();
const MAX_CACHE_SIZE = 1000;

function addToCache(key, value) {
  if (cache.size >= MAX_CACHE_SIZE) {
    const firstKey = cache.keys().next().value;
    cache.delete(firstKey);
  }
  cache.set(key, value);
}

How to fix FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory in Node.js

What this error means

Typical symptoms

Common causes

How to fix "FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory"

Advanced notes

Related errors

Official resources & further reading