How to fix Error: ENAMETOOLONG: name too long, open 'very_very_long_filename_exceeds_max_length' in Node.js

What this error means

The ENAMETOOLONG error (errno 36) is a filesystem-level error that Node.js throws when you attempt to create, open, or manipulate a file or directory whose name component exceeds the maximum length supported by the underlying filesystem. This error specifically refers to individual path components (a single filename or directory name), not the entire path. Most modern filesystems impose a limit of 255 bytes per component, though this can vary by filesystem type and encoding. The error typically manifests during file operations like fs.open(), fs.writeFile(), fs.mkdir(), or any other fs module method that creates or accesses filesystem entries. It's important to note that byte length can differ from character length, especially with multi-byte UTF-8 characters.

Typical symptoms

• Filesystem operations fail with ENAMETOOLONG error code
• File creation or directory creation throws "name too long" error
• Dynamically generated filenames fail unexpectedly
• Build processes or test runners crash with path-related errors
• npm or pnpm installs fail with ENAMETOOLONG in node_modules
• Data export or cache operations fail when generating filenames from content

Common causes

1. Filename component exceeds 255 bytes on ext4, APFS, or NTFS filesystems
2. Dynamically generated filenames using long slugs, timestamps, or concatenated strings
3. Base64-encoded data or hash values used directly as filenames without truncation
4. Deep node_modules nesting causing flattened paths to exceed limits
5. URL slugs or user input used as filenames without length validation
6. Automated test frameworks generating long descriptive filenames
7. Cache keys or serialized data structures used as filenames
8. Multi-byte UTF-8 characters causing byte length to exceed character count limit

How to fix "Error: ENAMETOOLONG: name too long, open 'very_very_long_filename_exceeds_max_length'"

Error: ENAMETOOLONG: name too long, open '/path/to/very_long_filename...'
    at Object.openSync (node:fs:600:3)

const path = require('path');
const filename = 'your_problematic_filename_here';
const byteLength = Buffer.byteLength(filename, 'utf8');
console.log(`Filename: ${filename}`);
console.log(`Byte length: ${byteLength}`);
console.log(`Character length: ${filename.length}`);

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

function validateFilename(filename, maxBytes = 255) {
  const byteLength = Buffer.byteLength(filename, 'utf8');
  if (byteLength > maxBytes) {
    throw new Error(
      `Filename exceeds maximum length: ${byteLength} bytes (max: ${maxBytes})`
    );
  }
  return filename;
}

// Use it before file operations
const filename = generateFilename(); // your filename generation logic
validateFilename(filename);
fs.writeFileSync(path.join('/some/dir', filename), data);

const crypto = require('crypto');
const path = require('path');

function truncateFilename(filename, maxBytes = 255) {
  const ext = path.extname(filename);
  const basename = path.basename(filename, ext);
  const byteLength = Buffer.byteLength(filename, 'utf8');

  if (byteLength <= maxBytes) {
    return filename;
  }

  // Reserve space for extension and hash
  const hashLength = 8;
  const maxBaseLength = maxBytes - Buffer.byteLength(ext, 'utf8') - hashLength - 1;

  // Truncate basename and add hash of original
  const hash = crypto
    .createHash('md5')
    .update(basename)
    .digest('hex')
    .slice(0, hashLength);

  let truncated = basename;
  while (Buffer.byteLength(truncated, 'utf8') > maxBaseLength) {
    truncated = truncated.slice(0, -1);
  }

  return `${truncated}-${hash}${ext}`;
}

// Example usage
const longFilename = 'very_very_long_filename_that_exceeds_filesystem_limits.json';
const safeFilename = truncateFilename(longFilename);
console.log(safeFilename); // very_very_long_filename_that_exceeds_filesys-a1b2c3d4.json

// BAD: Concatenating multiple long strings
const filename = `${userId}_${timestamp}_${description}_${category}_${tags.join('_')}.json`;

// GOOD: Use hierarchical directories and shorter names
const dir = path.join('data', userId, category);
const filename = `${timestamp}.json`;
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, filename), data);

// GOOD: Use UUIDs or short hashes
const { v4: uuidv4 } = require('uuid');
const filename = `${uuidv4()}.json`;

// GOOD: Store metadata separately from filename
const filename = 'data.json';
const metadata = { userId, description, category, tags };
fs.writeFileSync(path.join(dir, filename), data);
fs.writeFileSync(path.join(dir, 'metadata.json'), JSON.stringify(metadata));

# For npm: Update to latest version (better at flattening dependencies)
npm install -g npm@latest

# For pnpm: Use shamefully-hoist to flatten node_modules
echo "shamefully-hoist=true" >> .npmrc
pnpm install

# For any package manager: Clean and reinstall
rm -rf node_modules package-lock.json
npm install

npm install -g pnpm
pnpm install

Advanced notes

const filename = '你好世界.txt'; // Chinese characters
console.log(filename.length); // 7 (characters)
console.log(Buffer.byteLength(filename, 'utf8')); // 15 (bytes)

Frequently asked questions

What does "ENAMETOOLONG" mean?

js throws when you attempt to create, open, or manipulate a file or directory whose name component exceeds the maximum length supported by the underlying filesystem. This error specifically refers to individual path components (a single filename or directory name), not the entire path. Most modern filesystems impose a limit of 255 bytes per component, though this can vary by filesystem type and encoding.

How do I fix "ENAMETOOLONG"?

This error occurs when a file or directory name exceeds the maximum length allowed by the operating system's filesystem. Most filesystems limit individual filename components to 255 bytes, and Node.js throws ENAMETOOLONG when attempting filesystem operations with paths that exceed this limit.

What causes "ENAMETOOLONG"?

Filename component exceeds 255 bytes on ext4, APFS, or NTFS filesystems Dynamically generated filenames using long slugs, timestamps, or concatenated strings Base64-encoded data or hash values used directly as filenames without truncation

Is the "ENAMETOOLONG" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• Error: The encoding 'utf-16' is not supported (unsupported encoding)

  Unsupported encoding error in Node.js

  MEDIUM

• Error: EMFILE: too many open files, open 'file.txt'

  EMFILE: too many open files

  HIGH

• Error: connect ENETUNREACH 10.0.0.1:443

  ENETUNREACH: Network is unreachable

  MEDIUM

• Error: EISDIR: illegal operation on a directory, read

  EISDIR: illegal operation on a directory

  MEDIUM

• 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
• 📖
  Node.js File System Module - Path Limits(Official Docs)
• 🐙
  fs: confusing error when file name is too long(GitHub)
• 🐙
  Very long path names cause ENAMETOOLONG errors(GitHub)
• 📝
  Reduce the path length of a Node.js project