Let's skip the introductions. You're here because you want to check the Node.js version. This article is written exactly to address that need. In this guide, you'll learn how to check the Node.js version on Windows, Linux and macOS and more importantly, how to interpret the version numbers themselves. So, stay with us until the end of the article.
Quick Answer: Node.js Version Commands
If you just want the command, use node -v or node --version. If it prints something like v20.11.0, Node.js is installed and your current shell can see it.
node -v
node --version
npm -v
nvm ls
nvm current
Here's the short version: node -v checks the active Node.js version in your current terminal session. If the command fails, Node either isn't installed, or it is installed but not available on your PATH.
If you're brand new to this stack, it may help to read what Node.js is first. That gives you the runtime context before you start chasing version mismatches.
| Goal | Command | Example Output | Works On |
| Check active Node.js version | node -v |
v20.11.0 |
Windows, macOS, Linux |
| Check active Node.js version | node --version |
v20.11.0 |
Windows, macOS, Linux |
| Check npm version | npm -v |
10.2.4 |
Windows, macOS, Linux |
| List installed Node versions with nvm | nvm ls |
v18.20.2, v20.11.0 |
macOS, Linux, Windows with nvm-windows |
| Show current nvm-selected version | nvm current |
v20.11.0 |
macOS, Linux, some nvm setups |
| List installed Node versions with fnm | fnm ls |
v18.20.2 default, v20.11.0 |
Windows, macOS, Linux |
Why Check Your Node.js Version?
Checking your Node.js version is all about being accurate with what your runtime environment is based on before you start working and what you can reasonably get from it.
- That is because some libraries and frameworks are only compatible with certain versions of Node.js, and if you happen to use the wrong version, you will likely get errors.
- It is necessary for you to have your Node.js version updated if you want to be able to use new features or if you wish to have better performance.
- Conflicts between Node.js and npm versions can result in difficulties when trying to install packages or run CLI tools.
- When you are involved in multiple projects, each requiring a different version of Node.js, being aware of which version is currently active, thereby, helps you to prevent conflicts and errors.
Node.js Versioning Structure
A professional developer would consider just knowing a version number as insufficient. Such a developer would want to know deeply what the number actually means and the lifecycle that is associated with it. Node.js adopts a time-based release model, and accordingly, it is insightful to know that the even–odd rule and Long-Term Support (LTS) phases are two factors that help one to make software architecture decisions which are logical.
Understanding Semantic Versioning (SemVer) in Node.js
Node.js applies Semantic Versioning which is a system of versioning where the versions are identified by three numbers X.Y.Z:
- X (Major): This refers to the changes that are major and may potentially break the existing code.
- Y (Minor): These changes bring new features without impacting the existing features.
- Z (Patch): In the case of bugs, the patch versions offer fixes and are minor security issues that are compatible with the previous versions.
This versioning system is designed in such a way that helps you have a better comprehension of the current state of Node.js on your computer.
Even vs. Odd Major Versions
Among distinctions in Node.js releases that are related to the major version number the most important one is whether that number is even or odd:
- Current (Odd) Releases: The versions of 19 or 21 are examples. These versions are being developed further, supported only for about six months, and can be used only for testing new features but not for production purposes.
- Long-Term Support (LTS) Releases: After six months, the major versions with an even number, e.g., 18 or 20, will be eligible for the Long-Term Support. Their primary goal is to be stable and secure and, thus, they are the only ones to be recommended for production projects.
The support a version receives after entering the LTS phase is about 30 months: First 18 months make the Active LTS period when the version is regularly updated and bug fixes are done. The last 12 months are called Maintenance LTS, during which time only security fixes will be released and the migration planning should be done.
The following table briefly describes the statuses of the Node.js releases:
| Release Type | Major Number | Active Support Duration | Total LTS Duration | Production Recommendation |
| Current | Odd | 6 months | — | Not suitable |
| Active LTS | Even | 18 months | 30 months | Strongly recommended |
| Maintenance LTS | Even | 12 months | 30 months | Migration planning needed |
If you have not yet installed Node.js and want instructions on how to install it, or you are simply not sure about the installation process, then you may want to consider How to Install Node.js which will take you through the installation step by step.
How to Check If Node.js Is Installed
A lot of people don't actually want to "check Node version." They want to check if Node.js is installed at all. Slightly different question. Same first command.
Run node -v. If you get a version string like v18.19.1 or v20.11.0, you have Node installed and available in that shell. If you get an error instead, Node is either missing or your PATH environment variable isn't pointing to the Node binary.
On Windows CMD
Open Command Prompt and run node -v. If Node is present, you'll see a result that starts with v. If not, Windows usually prints: 'node' is not recognized as an internal or external command, operable program or batch file. That message usually means one of two things: Node isn't installed, or the installer added files but the PATH entry is missing or broken.
On PowerShell
In PowerShell, run node -v. You can also check whether PowerShell can resolve the executable path with Get-Command node. If nothing useful comes back, your shell probably can't find Node — especially common after installing Node and forgetting to open a fresh terminal window.
On macOS or Linux Terminal
Open Terminal and run node -v. If Node is installed and on your PATH, you'll get a version number. If not, you may see command not found: node. That doesn't always mean "not installed." Sometimes it means "installed somewhere your shell profile doesn't load."
If you need a version manager, install NVM and use that consistently.
What it means if the command fails
- Version returned: Node is installed and active in that shell.
- Command not found / not recognized: Node probably isn't installed, or PATH is wrong.
- Different result in different terminals: You likely have multiple installs, shell-specific config, or a version manager in play.
If Node is missing, go install it first. This guide on how to install Node.js is the logical next step.
Checking Versions via the Command Line
The least complicated and most direct method to find out the version of Node.js and its associated tools is to employ the command line. This elementary procedure is identical for all operating systems and thus helps to maintain the same level of consistency in your development environment.
Using node -v or node --version
To figure out the Node.js version that is currently active in your terminal session, you may employ either the short or the long flag. Both invocations produce exactly the same result:
node -v
# or
node --version
After running this command, you'll see an output like v20.11.0. The leading v indicates "version."
Checking the NPM Version
Typically, NPM which stands for Node Package Manager is installed by default with Node.js, however, it is still important to make sure that the version of your package manager is compatible and up to date as well. Having NPM in an old version can make the installation process extremely slow and result in a different way of locking project dependencies.
npm -v
// or
npm --version
What is the purpose of checking NPM?
Each version of Node.js is linked to a specific stable and bundled version of NPM. In any case, NPM is a completely independent project and it is updated much more frequently. Most of the times, newer versions of NPM are equipped with better dependency resolution algorithms and faster installation performance. Even though updating Node.js will also update NPM to the bundled version, you still have the option of upgrading NPM separately if you are willing to use the newest features.
Checking Versions of Alternative Package Managers
If you use alternative package managers in your projects (such as Yarn or pnpm), you can check their versions using the --version flag as well:
yarn --version
pnpm --version
One positive aspect of the Node.js ecosystem is that it's designed to behave consistently across different environments. Commands like node -v and npm -v work the same way in common shells — whether it's Bash or Zsh on Linux and macOS, or PowerShell and Command Prompt on Windows.
npm is usually bundled with Node, but its version has its own release track. If you want a deeper walkthrough, see how to check npm version. For choosing the right package manager for your project, you can also compare npm vs Yarn vs pnpm.
Checking Node.js Version Programmatically
In advanced and large-scale projects, especially when building developer tools, you may need the application itself to detect the active Node.js version at runtime. This capability is essential for implementing conditional compatibility checks or ensuring that the code runs in a specific environment.
Using the Global process.version Variable
// check-version.js
const fullVersionString = process.version;
console.log('Node.js Version:', fullVersionString);
// Example output: v20.11.0
Implementing Compatibility Logic
// Checking compatibility with a new API
const majorVersion = parseInt(process.version.slice(1));
if (majorVersion >= 24) {
console.log('Running Node.js 24 or newer, using latest features.');
// Logic for Node 24
} else {
console.log('Running an older Node.js version, falling back to older APIs.');
// Backward compatibility logic
}
NPM Environment Variables
console.log(
'Project Version defined in package.json:',
process.env.npm_package_version
);
Reading the File Directly
// In CJS (CommonJS) environments
const { version } = require('./package.json');
console.log(`Project Version: ${version}`);
// In ESM (ES Modules) environments
// import { version } from './package.json' assert { type: 'json' };
Using process.versions.node
console.log(process.versions.node);
This returns just the Node version number, usually without the extra formatting noise. I prefer this for scripts that compare versions programmatically.
Checking package.json and engines.node
{
"engines": {
"node": ">=18 <23"
}
}
This tells you the supported runtime range. If your local version falls outside that range, package managers or build tools may throw an unsupported engine error.
Reading a project's .nvmrc
Many teams pin a project-specific Node version in a file named .nvmrc. It may contain something like 20 or v20.11.0. If that file exists in the project root, it's a strong hint that you should switch to that version before installing dependencies or starting the app.
Using nvm to Manage and Check Node.js Versions
If you work with multiple versions of Node.js or need to switch between them frequently, the nvm tool (Node Version Manager) can be extremely useful. nvm allows you to install multiple Node.js versions and change the active version whenever you need.
After installing nvm (which is typically used on macOS and Linux; on Windows you can use nvm-windows), you can list the Node.js versions installed on your system with:
nvm ls
This command lists all installed versions and marks the currently active one with an arrow (->). For example, the output might look like this:
$ nvm ls
v12.22.1
-> v14.17.0
system
default -> 14.17.0 (-> v14.17.0)
node -> stable (-> v14.17.0) (default)
In this example, v14.17.0 is the active version (indicated by ->). If you run nvm current, it will display only the currently active version number:
$ nvm current
v14.17.0
With nvm, you can install and activate a different Node.js version whenever needed:
nvm install 16 # Install Node.js version 16
nvm use 16 # Use Node.js version 16
After doing this, running node -v will show version 16. If you want to update to the latest Node.js version, simply run:
nvm install node
One major thing that you should always remember is that nvm is generally a development environment tool for your local machine. It is not frequently used on production servers. In development environments and multi-project scenarios, nvm is a very efficient tool which simplifies your multiple Node.js version management.
Alternative: FNM is a sleek and quick new NVM alternative which is built in Rust. As it is run as a compiled binary, it is far more performant and can work on Windows without the need for a separate version. Its usage is very similar to NVM and can help in installing, using, and listing Node.js versions by issuing commands like fnm install, fnm use, and fnm ls respectively.
Troubleshooting Common Issues
While verifying the version of your Node.js, you may encounter errors that are typical. We ought to examine these errors one by one together with their correction methods:
1. Error: 'node' is not recognized as an internal or external command (Windows)
It is common that this message indicates that Node.js has not been installed or its path is not in the system PATH. Make sure that Node.js is installed, restart your computer if necessary, and check that PATH contains C:\Program Files\nodejs\. Run where node or where.exe node. If nothing returns, Node isn't on PATH. Reopen the terminal first. If that fails, repair the install or reinstall Node.
2. The node command is not working on Linux
On a few older Linux versions, Node.js is referred to as nodejs instead of node. If node -v fails, try:
nodejs -v
In case it is successful, make a symbolic link:
sudo ln -s /usr/bin/nodejs /usr/bin/node
3. The versions of Node.js and npm differ
If only one of them is old, some packages may fail. In general, upgrading Node.js to the latest LTS version also brings npm up-to-date. If npm errors out while Node works, check your package manager setup and consider reading how to verify npm version before changing anything.
4. Several Node.js versions installed and the wrong one is active
Check the active version by using nvm ls or nvm current. If you don't have nvm, check Node.js installation directories (e.g. C:\Program Files\nodejs\) and remove old versions if necessary.
5. Terminal shows a different version than expected
First, confirm the executable path with which node or where node. Then check whether your shell has cached command locations. On Unix-like systems, try reopening the terminal or refreshing the shell.
6. VS Code terminal shows a different Node version
VS Code may launch with a different shell profile, or it may not inherit your updated environment. Try: run node -v in both system and VS Code terminals, compare which node or where node, and restart VS Code if versions differ.
Node.js LTS vs Current: Which Version Should You Use?
This comes up constantly, and the practical answer is pretty simple.
- Use LTS for most real work: Pick LTS if you're running production services, shared dev environments, CI/CD pipelines, or client projects.
- Use Current when you need newer features: If you're testing upcoming platform features, building on the newest APIs, or doing experimental work, Current can make sense.
- My rule of thumb: If you're asking the question, start with LTS. Not glamorous. Very effective.
How to Update Node.js After Checking Your Version
After checking your current Node.js version, you might find that the installed version is outdated and needs to be updated. There are several ways to update Node.js, depending on your operating system and tools:
Updating with NVM
# Install the new LTS version (e.g., 24) and transfer global packages from version 20
nvm install 24 --reinstall-packages-from=20
After installation, activate the new version and verify:
nvm use 24
node -v # Should show the new version (v24.x.x)
npm -v # Should show the NPM version compatible with v24
If you always want to install the latest LTS version:
nvm install --lts
Updating NPM Independently
npm install -g npm
After updating, be sure to check the new version with npm -v.
Verify the update worked
node -v
npm -v
which node
where node
If the version didn't change, you probably updated one install source while another binary still wins on PATH.
If you encounter any issues during the update or need a more detailed guide on updating Node.js, I recommend reading the article How to Update Node.js, which explains the steps in detail.
Common Node.js Version Commands Cheat Sheet
| Task | Command | What It Shows |
| Check current Node version | node -v |
Active Node.js version in the current shell |
| Check current Node version | node --version |
Same as node -v |
| Check npm version | npm -v |
Installed npm version |
| Check Yarn version | yarn -v |
Installed Yarn version |
| Check pnpm version | pnpm -v |
Installed pnpm version |
| List installed Node versions with nvm | nvm ls |
All locally installed Node versions under nvm |
| Show active nvm version | nvm current |
Current nvm-selected version |
| List installed Node versions with fnm | fnm ls |
Installed versions managed by fnm |
| Find active Node binary on macOS/Linux | which node |
Path to the Node executable in use |
| Find active Node binary on Windows | where node |
Path or paths to Node executables found on PATH |
| Check fallback binary name on some Linux systems | nodejs -v |
Node version if binary is named nodejs |
Conclusion
In the fast-paced world of web development, staying updated with the latest tools and technologies is crucial. Node.js, with its versatile capabilities and active community, is a prime example of such a tool. Checking your Node.js version is a fundamental practice that ensures you're harnessing the full power of this runtime environment.
By keeping your Node.js version up to date, you're not only benefiting from bug fixes and performance enhancements but also ensuring that your applications and projects remain compatible with the latest features. This proactive approach can save you time and effort in the long run, preventing compatibility issues and streamlining your development workflow.
For next steps, you can use Node.js VPS if you're moving from local setup to deployment. For a full deployment walkthrough, check out how to deploy a Node.js application on a VPS.
