How to fix Error: Callback in setImmediate threw (delayed callback execution failed) in Node.js

Node.jsINTERMEDIATEMEDIUMUpdated Dec 9, 2025· 179 views

Your setImmediate() callback threw an unhandled exception or failed during execution. This error occurs because exceptions in setImmediate callbacks cannot be caught with try-catch and propagate unchecked through the Node.js event loop, crashing your process.

Quick fix

Fixes Error: Callback in setImmediate threw (delayed callback execution failed)

setImmediate(() => {
  try {
    // Synchronous operations
    const data = JSON.parse(jsonString);
    processData(data);
  } catch (error) {
    console.error('Error in setImmediate callback:', error);
    // Handle error appropriately
  }
});
  1. Wrap synchronous operations in try-catch inside the callback
  2. Register a process.on('uncaughtException') handler as a safety net
  3. Handle promise rejections if using Promises in setImmediate
  4. Use error-first callbacks for async operations
node.js — error
setImmediate(() => {
  try {
    // Synchronous operations
    const data = JSON.parse(jsonString);
    processData(data);
  } catch (error) {
    console.error('Error in setImmediate callback:', error);
    // Handle error appropriately
  }
});
Error: Callback in setImmediate threw (delayed callback execution failed)

What this error means

When you use setImmediate() to schedule a callback for execution after the current event loop phase completes, any error thrown within that callback executes asynchronously—after your synchronous code has already exited. Try-catch blocks only work for synchronous code in the same call stack, so they cannot intercept these asynchronous errors. When an error escapes a setImmediate callback, it propagates to the Node.js internals as an uncaught exception. If no global error handler is registered, Node.js terminates the entire process with an uncaught exception error.

Typical symptoms

  • Node.js process exits unexpectedly with 'uncaughtException' error
  • setImmediate callback throws an error that is not caught by try-catch
  • Error message shows the exception originated from within setImmediate
  • Application crashes without graceful error handling
  • Error handler registered on EventEmitter is never called

Common causes

  1. Throwing an error inside a setImmediate callback without a surrounding try-catch block
  2. No global process.on('uncaughtException') handler registered to catch escaped errors
  3. Forgetting that try-catch only works for synchronous code, not asynchronous callbacks
  4. Missing error handler on EventEmitters used within setImmediate
  5. Unhandled promise rejection within a setImmediate callback without a rejection handler
  6. Accessing undefined properties or calling methods on null/undefined objects in the callback

How to fix "Error: Callback in setImmediate threw (delayed callback execution failed)"

1Wrap synchronous operations in try-catch inside the callback

Add a try-catch block inside your setImmediate callback to handle any synchronous errors that might occur during execution:

javascript
setImmediate(() => {
  try {
    // Synchronous operations
    const data = JSON.parse(jsonString);
    processData(data);
  } catch (error) {
    console.error('Error in setImmediate callback:', error);
    // Handle error appropriately
  }
});

This catches synchronous errors like JSON parsing failures or TypeError from undefined properties, but will not catch asynchronous errors (like rejected promises).

2Register a process.on('uncaughtException') handler as a safety net

Add a global uncaught exception handler at the top level of your application to catch errors that escape setImmediate callbacks:

javascript
process.on('uncaughtException', (error) => {
  console.error('Uncaught exception:', error);
  // Log the error, send to monitoring service, or gracefully shutdown
  // Important: After this handler, Node.js behavior is unpredictable
  // Consider restarting the process
  process.exit(1);
});

setImmediate(() => {
  throw new Error('This error will be caught by uncaughtException handler');
});

Note: After an 'uncaughtException' handler runs, the application is in an undefined state. Best practice is to log the error and restart the process.

3Handle promise rejections if using Promises in setImmediate

If you use promises within setImmediate, register a handler for unhandled promise rejections:

javascript
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled rejection at:', promise, 'reason:', reason);
  // Handle the rejected promise
});

setImmediate(async () => {
  // This rejection would be caught by unhandledRejection handler
  return Promise.reject(new Error('Async operation failed'));
});

This is especially important if you're using async/await or returning promises from setImmediate callbacks.

4Use error-first callbacks for async operations

Instead of throwing errors, use error-first callback patterns or promises to propagate errors from setImmediate:

javascript
// Good: Using error-first callback pattern
function asyncOperation(callback) {
  setImmediate(() => {
    try {
      const result = performSomeOperation();
      callback(null, result);
    } catch (error) {
      callback(error);
    }
  });
}

asyncOperation((error, result) => {
  if (error) {
    console.error('Operation failed:', error);
    return;
  }
  console.log('Result:', result);
});

// Alternative: Using promises
function asyncOperationPromise() {
  return new Promise((resolve, reject) => {
    setImmediate(() => {
      try {
        const result = performSomeOperation();
        resolve(result);
      } catch (error) {
        reject(error);
      }
    });
  });
}

asyncOperationPromise()
  .then(result => console.log('Result:', result))
  .catch(error => console.error('Operation failed:', error));

This approach gives you control over error handling without relying on global handlers.

5Prefer async/await with proper error handling

For cleaner code, use async/await inside setImmediate, which works well with try-catch:

javascript
async function main() {
  setImmediate(async () => {
    try {
      const result = await someAsyncOperation();
      console.log('Success:', result);
    } catch (error) {
      console.error('Error in async setImmediate:', error);
      // Handle error without crashing the process
    }
  });
}

main().catch(error => {
  console.error('Fatal error:', error);
  process.exit(1);
});

Async functions return promises, which can be properly awaited and error-handled with try-catch.

6Validate inputs before processing in setImmediate

Add defensive checks to prevent runtime errors from undefined or invalid data:

javascript
setImmediate(() => {
  try {
    // Defensive checks
    if (!data || typeof data !== 'object') {
      console.error('Invalid data received');
      return;
    }

    if (!data.id || typeof data.id !== 'number') {
      console.error('Invalid data.id');
      return;
    }

    // Safe to proceed
    processData(data);
  } catch (error) {
    console.error('Error processing data:', error);
  }
});

This prevents TypeError exceptions from accessing properties on null/undefined values.

Advanced notes

setImmediate schedules callbacks for execution during the Check phase of the Node.js event loop, after the I/O phase completes. Importantly, errors thrown in setImmediate callbacks cannot be caught by try-catch blocks because the callback executes asynchronously in a different call stack. Starting with Node.js 13+, error handling in setImmediate became more deterministic—if an error occurs during Immediate processing, the remaining queue is scheduled to finish after all error handling code runs. For mission-critical operations, consider using async/await with promises instead of raw setImmediate, as they provide more predictable error handling semantics. In Express.js applications, errors from setImmediate should never be thrown directly; instead, pass them to the next() middleware to be caught by error handling middleware. If you're using worker threads or child processes, remember that errors in the main process and worker thread need separate handlers.

Frequently asked questions

What does "Error: Callback in setImmediate threw (delayed callback execution fail" mean?
When you use setImmediate() to schedule a callback for execution after the current event loop phase completes, any error thrown within that callback executes asynchronously—after your synchronous code has already exited. Try-catch blocks only work for synchronous code in the same call stack, so they cannot intercept these asynchronous errors. js internals as an uncaught exception.
How do I fix "Error: Callback in setImmediate threw (delayed callback execution fail"?
Your setImmediate() callback threw an unhandled exception or failed during execution. This error occurs because exceptions in setImmediate callbacks cannot be caught with try-catch and propagate unchecked through the Node.js event loop, crashing your process.
What causes "Error: Callback in setImmediate threw (delayed callback execution fail"?
Throwing an error inside a setImmediate callback without a surrounding try-catch block No global process.on('uncaughtException') handler registered to catch escaped errors Forgetting that try-catch only works for synchronous code, not asynchronous callbacks
Is the "Error: Callback in setImmediate threw (delayed callback execution fail" error serious?
It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Official resources & further reading