How to Clear npm Cache and node_modules on Mac

Why node_modules and the npm Cache Get So Big

If you have written any JavaScript on your Mac, you have met the joke: node_modules is the heaviest object in the universe. It is only half a joke. A single modern web project can install hundreds or even thousands of transitive dependencies, and each one arrives with source code, compiled binaries, documentation, and tests. A typical React or Next.js project's node_modules folder routinely lands between 200 MB and 1 GB.

The problem compounds. node_modules is per-project, so if you have twenty repositories cloned on your Mac, you have twenty separate copies of largely overlapping dependencies. Old projects you have not touched in a year still hold their full node_modules on disk. It is not unusual for a developer's home folder to contain 20–50 GB of node_modules across abandoned and active projects combined.

Separately, npm keeps a global cache at ~/.npm (specifically ~/.npm/_cacache). Every package tarball npm downloads is stored here so future installs can be served from disk instead of the network. This cache is content-addressed and grows over time, and while npm is generally good at self-healing it, it can still swell to several gigabytes.

How to Find Where the Space Is Going

Before deleting anything, measure. The du command tells you how much disk a folder is using. To check the npm cache size, open Terminal and run:

du -sh ~/.npm

To find every node_modules folder under your home directory and see how big each one is, use find together with du:

find ~ -name "node_modules" -type d -prune -exec du -sh {} +

The -prune flag stops find from descending into nested node_modules (a node_modules folder can contain more node_modules), which keeps the numbers accurate and the search fast. The output is a list of paths and sizes, so you can immediately spot which old projects are worth cleaning.

To get a single grand total across all of them:

find ~ -name "node_modules" -type d -prune -print0 | xargs -0 du -ch | tail -1

How to Clear the npm Cache

npm gives you a dedicated command for cache maintenance. In recent npm versions the cache is self-repairing, so the "force" flag is required to wipe it outright.

1. 1
   Check the cache health first. Run npm cache verify. This validates the cache contents, removes any corrupted or unused entries, and reports how much is stored. Often this alone reclaims space without a full wipe.
2. 2
   Force-clear the entire cache. If you want it all gone, run npm cache clean --force. The --force flag is mandatory because npm considers a full wipe unnecessary under normal use.
3. 3
   Confirm the reclaim. Run du -sh ~/.npm again to see the cache has shrunk. Your next npm install will rebuild only what it needs.

How to Delete node_modules Safely

Deleting node_modules is completely safe as long as the project has a valid package.json and lockfile. Everything in node_modules is reproducible: running npm install rebuilds it exactly from your package-lock.json. You are never deleting your own source code — only downloaded dependencies.

Delete a single project's node_modules

From inside a project folder, simply remove it:

rm -rf node_modules

When you next need the project, run npm ci (a clean, lockfile-exact install) or npm install to restore it.

Delete node_modules from old projects in bulk

To reclaim space from projects you are no longer actively developing, you can remove every node_modules folder under a directory at once. Preview first, then delete:

find ~/projects -name "node_modules" -type d -prune -print

Once you have confirmed the list looks right, run the deletion:

find ~/projects -name "node_modules" -type d -prune -exec rm -rf {} +

The one caveat: a very small number of packages run install scripts that fetch platform-specific binaries. These are re-fetched automatically on the next install, so they cost you a little download time but nothing permanent.

Keeping node_modules Bloat Under Control

A few habits keep JavaScript disk usage from spiraling:

• Delete node_modules from dormant projects. If you have not touched a repo in months, remove its node_modules. It restores in seconds when you come back.
• Use pnpm for shared storage. pnpm hard-links packages from a single global store, so identical dependencies across projects are stored on disk only once — a dramatic saving if you juggle many repos.
• Run npm cache verify periodically. This keeps the global cache lean without a destructive full wipe.
• Add node_modules to .gitignore. This is standard, but worth confirming — you never want these folders bloating your repository or backups.

Finding node_modules Bloat with TrimyMac

Hunting down every stale node_modules folder with find works, but it means remembering the flags and reading through raw terminal output. TrimyMac scans your Mac and surfaces the largest space consumers visually — including sprawling node_modules folders and developer caches tucked away in old project directories — so you can see at a glance which forgotten repos are costing you the most.

Instead of manually reconciling du output, you get a clear map of where your disk went and can clear developer clutter across your whole machine in one pass, while leaving your actual source code untouched.