ERR_REQUIRE_ESM

Exact Error Messages

Node.js produces one of these two error strings depending on the context:

Error [ERR_REQUIRE_ESM]: require() of ES Module
/project/node_modules/chalk/source/index.js
from /project/app.js not supported.
chalk is an ES module and cannot be required.
Instead use dynamic import():
  const chalk = await import('chalk');
    at Object.load (node:internal/modules/cjs/loader:1277:19)
    at Function.Module._resolveFilename (node:internal/modules/cjs/loader:1039:15)
    at Function.Module._load (node:internal/modules/cjs/loader:885:27)
    ...

Error [ERR_REQUIRE_ESM]: Must use import to load ES Module:
/project/node_modules/some-pkg/index.mjs
require() of ES modules is not supported.
require() of /project/node_modules/some-pkg/index.mjs
from /project/app.js is an ES module file as it is a .mjs file.
Instead change the require of index.mjs in /project/app.js to a dynamic import()
which is available in all CommonJS modules.

Node.js helpfully includes the exact import() fix right in the error message. The package name in the stack trace is your starting point.

What is ERR_REQUIRE_ESM?

ERR_REQUIRE_ESM is thrown when the CommonJS loader encounters a package or file that is a pure ES module — one that uses import/export syntax and cannot be loaded synchronously. require() is synchronous by design; ES modules are inherently asynchronous, so Node.js forbids mixing them this way.

Starting in late 2020, many widely-used npm packages dropped their CommonJS builds and became ESM-only, making this one of the most frequently encountered Node.js errors in 2023–2026.

All Causes

Root Cause in package.json

A package is a pure ES module when its package.json contains "type": "module", or when it ships only .mjs files with no CommonJS fallback. From that point on, require() cannot load it.

// node_modules/chalk/package.json (v5+)
{
  "name": "chalk",
  "type": "module"   // ← makes the entire package ESM-only
}

// A package with conditional exports but no "require" condition is also ESM-only:
{
  "exports": {
    ".": {
      "import": "./index.mjs"
      // no "require" key → require() will fail
    }
  }
}

Fix 1 – Use dynamic import() (recommended for CJS projects)

Replace require() with import(). This works in any CommonJS file — no project-wide changes needed.

// Before (broken)
const chalk = require('chalk');

// After – dynamic import returns a Promise
const { default: chalk } = await import('chalk');

// If you are not in an async context, wrap in an async IIFE:
(async () => {
  const { default: chalk } = await import('chalk');
  console.log(chalk.green('Hello'));
})();

// Useful pattern: lazy-load once and reuse
let _chalk;
async function getChalk() {
  if (!_chalk) _chalk = (await import('chalk')).default;
  return _chalk;
}

Fix 2 – Convert your project to ESM

If your codebase is entirely your own, converting to ESM is the cleanest long-term solution.

// 1. Add to your package.json:
{ "type": "module" }

// 2. Change require() to import:
import chalk from 'chalk';
import fetch from 'node-fetch';

// 3. Change module.exports to export:
export function myFunction() { ... }
export default myClass;

Note: converting to ESM disables __dirname and __filename — use import.meta.url with the URL constructor as a replacement.

import { fileURLToPath } from 'url';
import path from 'path';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const __filename = fileURLToPath(import.meta.url);

Fix 3 – Pin to the last CJS version

The easiest zero-code-change fix. Install the last version of the package that still shipped a CommonJS build.

Fix 4 – TypeScript-specific fix

TypeScript compiles import pkg from 'pkg' to const pkg = require('pkg') when "module": "commonjs" is set in tsconfig.json. This causes ERR_REQUIRE_ESM at runtime even though your TypeScript source looks correct.

Option A: Downgrade the package (quickest for TypeScript projects) — install the last CJS version as shown in Fix 3, plus its @types package if needed:

npm install node-fetch@2
npm install --save-dev @types/node-fetch@2.x

Option B: Change the TypeScript module target

// tsconfig.json
{
  "compilerOptions": {
    "module": "nodenext",      // or "es2020"
    "moduleResolution": "nodenext",
    "esModuleInterop": true,
    "target": "es2020"
  }
}

Option C: Use dynamic import() in TypeScript

// Works in TypeScript with any module target
const { default: chalk } = await import('chalk');

Fix 5 – Use createRequire() inside an ESM file

If you have converted your project to ESM but still need to load a CommonJS module (the reverse problem), use createRequire:

// In an .mjs file or a file in an ESM package:
import { createRequire } from 'module';
const require = createRequire(import.meta.url);

// Now you can require() CJS modules from an ESM context:
const someOldCjsPackage = require('some-old-cjs-pkg');

Fix 6 – Use .cjs file extension

If your project has "type": "module" in package.json but one specific file must remain CommonJS, rename it with a .cjs extension. Node.js always treats .cjs files as CommonJS regardless of the type field.

# Rename the file:
mv server.js server.cjs

# Now require() works inside server.cjs even when "type": "module" is set:
const express = require('express'); // fine in .cjs

Fix 7 – CJS-compatible alternatives

For some packages, a maintained CJS-compatible alternative exists:

• node-fetch → use the built-in fetch (Node.js 18+) or axios
• chalk → use kleur or colorette (both ship CJS builds)
• nanoid → use uuid or crypto.randomUUID() (Node.js 14.17+)
• got → use axios or the built-in https module
• execa → use child_process.execSync for simple cases

Fixing ERR_REQUIRE_ESM in Jest

Jest uses CommonJS by default, so importing an ESM-only package in a test fails immediately. You have several options:

Option A: Pin to the last CJS version (simplest)

npm install chalk@4   # Last CJS version of chalk

Option B: Enable Jest's experimental ESM mode

// package.json
{
  "type": "module",
  "scripts": {
    "test": "NODE_OPTIONS=--experimental-vm-modules jest"
  }
}

// jest.config.js (renamed to jest.config.mjs or with "type":"module")
export default {
  transform: {}   // disable transform — let Node handle ESM natively
};

Option C: Transform with Babel

// Install: npm install --save-dev babel-jest @babel/preset-env
// babel.config.js
module.exports = {
  presets: [['@babel/preset-env', { targets: { node: 'current' } }]]
};

Option D: Switch to Vitest (ESM-native, Jest-compatible API)

npm install --save-dev vitest
# Then replace jest with vitest in scripts

Fixing ERR_REQUIRE_ESM in Electron

Electron's main process runs as CommonJS by default. ESM-only npm packages cannot be directly require()d. Use a dynamic import() call instead:

// main.js (Electron main process)
// Before (broken):
const { default: open } = require('open');

// After (works):
async function openURL(url) {
  const { default: open } = await import('open');
  await open(url);
}

Diagnosing a Transitive Dependency Issue

If you never require() the ESM package yourself but still see the error, a transitive dependency is the culprit — one of your dependencies requires the ESM package.

# Find which package requires the ESM module:
npm ls chalk

# Output example:
my-project@1.0.0
└─┬ some-tool@3.0.0
  └── chalk@5.0.0  ← ESM-only chalk pulled in by some-tool

Solutions: (1) pin some-tool to a version that uses chalk@4; (2) use an npm overrides field to force the sub-dependency version:

// package.json — force chalk@4 everywhere in the tree
{
  "overrides": {
    "chalk": "^4"
  }
}

How to identify if a package is ESM-only

# Check the package.json of the installed version
cat node_modules/chalk/package.json | grep '"type"'
# "type": "module"  ← ESM-only

# Also check exports — no "require" key means ESM-only:
cat node_modules/chalk/package.json | grep -A 10 '"exports"'

Also look for the absence of a "main" field pointing to a .js file, or the presence of only "exports" with "import" conditions and no "require" condition.

Troubleshooting Checklist

1. Read the error message — Node.js prints the exact package name and the import() fix.
2. Check node_modules/<package>/package.json for "type": "module".
3. Run node --version — ensure you are on Node.js 14+ (dynamic import() requires Node 12.17+).
4. If you never directly require the package, run npm ls <package> to find the transitive dependency.
5. Check the package's changelog for the version that went ESM-only.
6. Delete node_modules and package-lock.json and run npm install after any version changes.
7. Decide: use import(), convert to ESM, pin to last CJS version, or use overrides.

Frequently Asked Questions

Related Errors

• ERR_PACKAGE_PATH_NOT_EXPORTED — the package is installed but the subpath is not in its exports map
• MODULE_NOT_FOUND — the package cannot be found at all
• ERR_IMPORT_ASSERTION_TYPE_MISSING — missing import assertion for JSON modules in ESM