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

What this error means

The "FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory" error indicates that your Node.js application has exhausted the available heap memory allocated to the V8 JavaScript engine. When this happens, V8 cannot allocate more memory for objects, arrays, or other data structures, causing the process to crash. Node.js uses V8's garbage-collected heap to store objects and data. By default, V8 limits the old space (where long-lived objects reside) to around 1.5GB on 64-bit systems and 512MB on 32-bit systems. This conservative default prevents Node.js from consuming all system memory, but it can be too restrictive for memory-intensive workloads. The error typically appears during operations that require substantial memory allocation, such as building large applications, processing massive datasets, running memory-intensive tests, or performing complex transformations on large files.

Typical symptoms

• Application crashes with "FATAL ERROR" message during execution
• Build processes fail when compiling or bundling large codebases
• npm install or package operations fail on large projects
• Tests crash when running extensive test suites
• Data processing scripts fail when handling large files or datasets
• Application works fine with small datasets but crashes with larger ones
• Memory usage gradually increases before the crash occurs

Common causes

1. Default Node.js heap size (1.5GB) insufficient for memory-intensive operations
2. Processing large files entirely in memory instead of using streams
3. Memory leaks preventing garbage collection from freeing unused memory
4. Large arrays or objects accumulated in memory without cleanup
5. Bundling or compiling large codebases with tools like webpack or Next.js
6. Running extensive test suites with insufficient memory allocation
7. Inefficient algorithms creating excessive temporary objects
8. Recursive operations creating deep call stacks with large data structures

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

node --max-old-space-size=4096 app.js

{
  "scripts": {
    "build": "node --max-old-space-size=4096 node_modules/.bin/next build",
    "test": "node --max-old-space-size=4096 node_modules/.bin/jest"
  }
}

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

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

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

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

NODE_OPTIONS="--max-old-space-size=4096"

const fs = require('fs');

const data = fs.readFileSync('large-file.json', 'utf8');
const parsed = JSON.parse(data); // Can cause memory errors

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

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

rl.on('line', (line) => {
  // Process each line individually
  console.log(line);
});

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

const pipeline = fs.createReadStream('large-array.json')
  .pipe(parser())
  .pipe(streamArray());

pipeline.on('data', ({ value }) => {
  // Process each array element individually
  console.log(value);
});

setInterval(() => {
  const usage = process.memoryUsage();
  console.log(`Heap Used: ${Math.round(usage.heapUsed / 1024 / 1024)} MB`);
  console.log(`Heap Total: ${Math.round(usage.heapTotal / 1024 / 1024)} MB`);
}, 5000);

node --inspect app.js

// Bad
events.forEach(event => {
  eventEmitter.on(event, handler);
});

// Good
events.forEach(event => {
  eventEmitter.on(event, handler);
});
// Later, when done:
events.forEach(event => {
  eventEmitter.removeListener(event, handler);
});

Advanced notes

node --max-old-space-size-percentage=75 app.js

# Expose GC metrics
node --max-old-space-size=4096 --expose-gc app.js

# Manual GC trigger (for testing only)
if (global.gc) {
  global.gc();
}

Frequently asked questions

What does "ERR_MEMORY_ALLOCATION" mean?

js application has exhausted the available heap memory allocated to the V8 JavaScript engine. When this happens, V8 cannot allocate more memory for objects, arrays, or other data structures, causing the process to crash. js uses V8's garbage-collected heap to store objects and data.

How do I fix "ERR_MEMORY_ALLOCATION"?

This error occurs when Node.js runs out of memory while executing your application. By default, Node.js limits heap memory to approximately 1.5GB on 64-bit systems, which may be insufficient for memory-intensive operations like processing large files or building complex applications.

What causes "ERR_MEMORY_ALLOCATION"?

Default Node.js heap size (1.5GB) insufficient for memory-intensive operations Processing large files entirely in memory instead of using streams Memory leaks preventing garbage collection from freeing unused memory

Is the "ERR_MEMORY_ALLOCATION" error serious?

Yes. This is a high-severity error that usually blocks work until it is fixed, but the steps above resolve it.

Related errors

• Error: HMAC key must be a string or buffer (invalid key type)

  HMAC key must be a string or buffer

  HIGH

• Error: HTTP 504 Gateway Timeout (upstream server timeout)

  HTTP 504 Gateway Timeout (upstream server timeout)

  HIGH

• Error: HPE_INVALID_HEADER_TOKEN: invalid header token

  HPE_INVALID_HEADER_TOKEN: Invalid header token in Node.js HTTP request

  MEDIUM

• Error: EMFILE: too many open files, watch

  EMFILE: fs.watch() limit exceeded

  HIGH

• Error: zlib error Z_DATA_ERROR (corrupted compressed data)

  Z_DATA_ERROR: Corrupted compressed data

  MEDIUM

• Error: Could not find package.json in current directory (npm module resolution)

  How to fix "Could not find package.json in current directory" in Node.js

  MEDIUM

Official resources & further reading

• 📚Node.js Official Documentation
• 🔗
  nodejs.org - understanding and tuning memory
• 🔗
  github.com - 10137
• 🔗
  developers.redhat.com - nodejs 20 memory management containers