How to fix RangeError: Maximum call stack size exceeded (infinite recursion) in Node.js

What this error means

A stack overflow happens when the call stack (a limited memory area that tracks function calls) becomes full. Every time a function is called, a new frame is added to the stack. In Node.js, there is a hard limit to how many frames can exist at once (typically around 10,000-30,000 depending on the system). When this limit is exceeded, the JavaScript engine throws a RangeError. This usually indicates infinite recursion where a function keeps calling itself without a way to stop, but can also result from deeply nested callback chains, circular event emissions, or operations on very large/deeply nested objects. The stack overflow indicates a bug in your code logic rather than a system resource shortage.

Typical symptoms

• Application crashes immediately with "RangeError: Maximum call stack size exceeded"
• Error appears to happen during a specific operation or function call
• Stack trace is very long and shows the same function repeating
• Performance suddenly drops before the crash (due to excessive function calls)
• Recursive function calls grow without visible progress
• Event listeners trigger themselves in an infinite loop
• Deep object cloning or serialization operations fail

Common causes

1. Recursive function missing base case or termination condition
2. Recursive function base case never being reached due to logic error
3. Event emitter triggering its own listener, creating infinite recursion
4. JSON.stringify() or similar operation on circular or very deeply nested objects
5. Deeply nested callback chains that don't properly break
6. Processing arrays or objects with extreme depth without iteration
7. Promise chaining creating excessive stack depth without proper handling
8. Mutual recursion between two or more functions without base cases

How to fix "RangeError: Maximum call stack size exceeded (infinite recursion)"

RangeError: Maximum call stack size exceeded
  at calculateFactorial (script.js:5:3)
  at calculateFactorial (script.js:6:3)
  at calculateFactorial (script.js:6:3)
  at calculateFactorial (script.js:6:3)
  ...repeated thousands of times...

let callCount = 0;
function calculateFactorial(n) {
  callCount++;
  console.log(`Call #${callCount}: n=${n}`);
  if (callCount > 100) {
    console.log('Stack overflow detected, exiting early');
    process.exit(1);
  }
  return calculateFactorial(n - 1);
}

function countdown(n) {
  console.log(n);
  return countdown(n - 1); // Always calls itself!
}

countdown(5); // RangeError: Maximum call stack size exceeded

function countdown(n) {
  if (n === 0) {
    console.log('Done!');
    return; // Base case: stop recursion
  }
  console.log(n);
  return countdown(n - 1);
}

countdown(5); // Logs: 5, 4, 3, 2, 1, Done!

function sumArray(arr, index = 0) {
  if (index === arr.length) {
    return 0;
  }
  return arr[index] + sumArray(arr, index + 1);
}

const largeArray = new Array(50000).fill(1);
sumArray(largeArray); // RangeError: stack overflow

function sumArray(arr) {
  let total = 0;
  for (let i = 0; i < arr.length; i++) {
    total += arr[i];
  }
  return total;
}

const largeArray = new Array(50000).fill(1);
console.log(sumArray(largeArray)); // Works fine: 50000

const { EventEmitter } = require('events');
const emitter = new EventEmitter();

emitter.on('data', (value) => {
  console.log(value);
  emitter.emit('data', value - 1); // Emits itself!
});

emitter.emit('data', 5); // RangeError

const { EventEmitter } = require('events');
const emitter = new EventEmitter();

emitter.on('data', (value) => {
  console.log(value);
  if (value > 0) {
    emitter.emit('data', value - 1);
  }
});

emitter.emit('data', 5); // Logs: 5, 4, 3, 2, 1, 0

const obj = { value: 1 };
obj.self = obj; // Circular reference!

JSON.stringify(obj); // RangeError: Maximum call stack size exceeded

const seen = new WeakSet();
const json = JSON.stringify(obj, (key, value) => {
  if (typeof value === 'object' && value !== null) {
    if (seen.has(value)) {
      return '[Circular]'; // Skip circular refs
    }
    seen.add(value);
  }
  return value;
});

function deepClone(obj, depth = 100) {
  if (depth === 0) {
    console.warn('Max depth reached, truncating object');
    return null;
  }
  if (typeof obj !== 'object' || obj === null) return obj;

  const cloned = Array.isArray(obj) ? [] : {};
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      cloned[key] = deepClone(obj[key], depth - 1);
    }
  }
  return cloned;
}

node --stack-size=2000 script.js

// Add this at the top of your script
let callCount = 0;
const originalFunc = someFunction;
someFunction = function(...args) {
  callCount++;
  if (callCount % 1000 === 0) {
    console.log(`Made ${callCount} calls so far...`);
  }
  return originalFunc(...args);
};

Advanced notes

// Risky: deeply chained promises
function recursivePromise(n) {
  if (n === 0) return Promise.resolve();
  return Promise.resolve().then(() => recursivePromise(n - 1));
}

recursivePromise(10000); // Can cause stack overflow

async function iterativeLoop(count) {
  for (let i = 0; i < count; i++) {
    await somethingAsync();
  }
}

Frequently asked questions

What does "RANGE_ERROR" mean?

A stack overflow happens when the call stack (a limited memory area that tracks function calls) becomes full. Every time a function is called, a new frame is added to the stack. js, there is a hard limit to how many frames can exist at once (typically around 10,000-30,000 depending on the system).

How do I fix "RANGE_ERROR"?

This error occurs when a function calls itself recursively without a proper base case or termination condition, exhausting the call stack. Stack overflow can also happen during deep object operations, circular event listeners, or when processing deeply nested data structures.

What causes "RANGE_ERROR"?

Recursive function missing base case or termination condition Recursive function base case never being reached due to logic error Event emitter triggering its own listener, creating infinite recursion

Is the "RANGE_ERROR" 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: The stream is destroyed

  Stream has been destroyed and cannot be used

  MEDIUM

• Error: SSL: CERTIFICATE_VERIFY_FAILED (SSL protocol error)

  How to fix SSL protocol error (CERTIFICATE_VERIFY_FAILED) in Node.js

  HIGH

• RangeError: highWaterMark must be a positive number (invalid stream config)

  RangeError: highWaterMark must be a positive number in Node.js streams

  HIGH

• Error: certificate verify failed (self-signed or expired SSL cert)

  How to fix certificate verify failed SSL error in Node.js

  HIGH

• Error: read ECONNRESET

  Read ECONNRESET - Connection reset by peer

  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
• 📖
  Node.js Errors Documentation - RangeError(Official Docs)
• 🐙
  RangeError Maximum call stack size exceeded on nodejs v17.9.0(GitHub)
• 📝
  Debugging Maximum Call Stack Size Exceeded in Node.js
• 📝
  JavaScript Error Handling: Maximum Call Stack Size Exceeded