3015

How can I find the version of an installed Node.js or npm package?

This prints the version of npm itself:

npm -v <package-name>

This prints a cryptic error:

npm version <package-name>

This prints the package version on the registry (i.e., the latest version available):

npm view <package-name> version

How do I get the installed version?

4
  • 24
    On my installation, "npm -v <package-name>" reports the version of npm, itself. To list the latest version of a package in the registry, I have found that "npm view <package-name> version" gets the job done. Commented Apr 29, 2018 at 20:25
  • 28
    npm show shows the latest in npm, not installed Commented Aug 26, 2019 at 16:18
  • 2
    most of the time <module-name> -v should work. However, this depends on whether or not the package developer(s) added cli functionality to their packages.
    – Nate T
    Commented Dec 21, 2020 at 7:39
  • If you're in the directory that its package.json is in, you can use npm pkg get version.
    – Jason C
    Commented Nov 14, 2022 at 23:31

32 Answers 32

3426

Use npm list for local packages or npm list -g for globally installed packages.

You can find the version of a specific package by passing its name as an argument. For example, npm list grunt will result in:

projectName@projectVersion /path/to/project/folder
└── [email protected]

Alternatively, you can just run npm list without passing a package name as an argument to see the versions of all your packages:

├─┬ [email protected]
│ └── [email protected]
├── [email protected]
├── [email protected]
├─┬ [email protected]
│ ├── [email protected]
│ └── [email protected]
└── [email protected]

You can also add --depth=0 argument to list installed packages without their dependencies.

11
  • 154
    On mac and linux it's nice to add " | grep module_name", to filter the desired module version. Especially when running globally with -g. For example: "npm list -g | grep express" to get the installed express version.
    – guya
    Commented Apr 16, 2013 at 1:51
  • 111
    If you want a specific module, you can run it like npm list less-middleware as an example.
    – juanpaco
    Commented Mar 16, 2014 at 19:43
  • 15
    Per @guya's tip for *nix based systems, on Windows you can use PowerShell for similar results: | select-string module_name to filter the module. Or, if you're using Git Bash (or just Bash, for that matter), you can use grep.
    – Noel
    Commented Feb 12, 2016 at 20:33
  • 16
    If you can't remember list, npm ls also works. In fact, many npm commands have aliases, and moreover, if you type a substring of a command, if this substring is unambiguous, it will work also; for instance npm ls, npm list, npm lis are all the same. If you want more verbose output, try npm ll (but probably you want --depth=0 added to it).
    – jakub.g
    Commented May 16, 2016 at 18:35
  • 7
    The output isn't the best for parsing with a script. Is there really not a way to get an output that is just the package version without having to do something like npm list -g | awk -F@ '/<package>/ { print $2}'
    – Thayne
    Commented Nov 7, 2017 at 19:09
1041

Another quick way of finding out what packages are installed locally and without their dependencies is to use:

npm list --depth=0

Which gives you something like

├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
└── [email protected]

Obviously, the same can be done globally with npm list -g --depth=0.

This method is clearer if you have installed a lot of packages.

To find out which packages need to be updated, you can use npm outdated -g --depth=0.

5
  • 16
    it's give me same as without the --depth
    – ygaradon
    Commented Feb 27, 2014 at 18:07
  • 8
    it seems they've fixed it in npm 1.4.6. See github.com/npm/npm/issues/4733
    – Howie
    Commented Jun 8, 2014 at 8:28
  • 9
    Works great with | grep <package_name> Commented Jul 1, 2015 at 14:14
  • 5
    @ygaradon Correct, but the --depth=0 makes it faster, because it does not have to recursively load dependencies Commented Jul 1, 2015 at 15:17
  • npm list -g --depth=0 for list modules installed globally
    – EdgeDev
    Commented Apr 9, 2019 at 22:51
296

npm view <package> version - returns the latest available version on the package.

npm list --depth=0 - returns versions of all installed modules without dependencies.

npm list - returns versions of all modules and dependencies.

And lastly to get the Node.js version: node -v

4
  • 32
    npm view <package> version, goes to the npm remote registry, not local filesystem... Commented Dec 5, 2016 at 9:19
  • @AlexanderMills True, but having it here avoids another search for that. Btw, npm v, npm info and npm show are all alias of npm view.
    – CPHPython
    Commented Jan 17, 2018 at 10:38
  • along the same lines, npm view <package> versions will return all the versions for the package and not just the latest one.
    – rgantla
    Commented Jul 6, 2020 at 19:52
  • @SalvadorDali Why do you steal the name and the face of a dead person? This should not be accepted...
    – vdegenne
    Commented Jan 2 at 20:46
113

Use

npm info YOUR_PACKAGE version

E.g.,

npm info grunt version

0.4.5
6
  • 181
    This doesn't show the installed package version, it just shows the latest available version. Commented Aug 22, 2015 at 16:56
  • 2
    Agree with @tanner-semerad. I checked into Docs of npm to clearify it. npm info is alias for npm view and in Docs of npm you will find that standing: This command shows data about a package and prints it to the stream referenced by the outfd config, which defaults to stdout. [...] The default version is "latest" if unspecified. That's way I vote down.
    – dannydedog
    Commented Jul 6, 2018 at 12:25
  • Shows the latest version available, not latest installed. Downvoted. Commented Nov 29, 2018 at 6:02
  • 2
    npm info YOUR_PACKAGE version The only one that worked :)
    – GOXR3PLUS
    Commented Jan 29, 2019 at 15:28
  • 1
    No, as mentioned this will show the latest version on the registry. This "seems" to work if by chance your local dependency is on the latest version. But if it's not, you will not see the actual installed (older) version with this command. Commented Jun 1, 2020 at 18:16
95

From the root of the package do:

node -p "require('./package.json').version"

(So you need to cd into the module's home directory if you are not already there. If you have installed the module with npm install, then it will be under node_modules/<module_name>.)

4
  • Nice! Quite a bit faster than running "npm list" as the other answers suggest (~1s instead of ~20s) -- at least when you have this code snippet ready! (there should really be an npm plugin to do this...)
    – Venryx
    Commented May 9, 2017 at 10:06
  • 2
    or node -p "require('./package.json').version" Commented Jul 5, 2017 at 21:14
  • 1
    I'd like to oppose @geedew 's comment. This answer suggests to be run in the root folder of the installed module. In the package.json of the installed module you will(!) find the actually installed version.
    – Michael K
    Commented Mar 8, 2021 at 16:46
  • 1
    Nice one-liner: (cd node_modules/<package name> && node -p "require('./package.json').version") Commented Mar 21 at 11:19
81

I just used

npm list | grep <package name>

and it worked great.

On Windows, run:

npm list | find <package name>

In PowerShell run:

npm list | sls <package name>
3
  • 4
    find version doesn't work for me - even with quoted string, but powershell works well
    – fiat
    Commented Jun 23, 2017 at 5:34
  • 6
    For Windows users: npm list -g --depth=0 |find "<package name>" Note the double quotes
    – robe007
    Commented Mar 8, 2019 at 19:51
  • How do you get only the version (without the rest of the stuff), and not just in Bash, but also in Windows PowerShell? You'd think they would have thought of this a long time ago.
    – trusktr
    Commented Nov 2, 2023 at 8:16
34

For local packages:

npm list --depth=0

For global packages:

npm list -g --depth=0
34

You can see file package.json to see installed packages versions.

To get the list on the command line,

npm ls

It will give you all installed packages in a project with their respective versions.

For a particular package version,

npm ls <package-name>

For example,

npm ls next

It will return version

-- [email protected]
0
33

WARNING: This answer shows the latest available version of a module in npm, not the currently installed version locally.


It's very simple.. Just type the below line

npm view <package-name> version

Example

npm view redux version

I have version 7.2.0 of Redux.

1
  • 124
    BEWARE: This is NOT showing the installed version. It shows the latest available version on npm. Commented Oct 1, 2020 at 8:53
29

Combining some of the above answers and produces a super simple and super quick lookup.

Run from the project root. There isn’t any need to cd into any folder, just one line:

node -p "require('SOMEPACKAGE/package.json').version"

1
  • This gives me the error "Package subpath './package.json' is not defined by "exports" in /path/to/SOMEPACKAGE/package.json". Did this used to work until a new node version broke it, or am I doing something wrong?
    – Bbrk24
    Commented Aug 22, 2023 at 4:40
24

If you agree to install jq, you can use the JSON output of npm list:

npm -j ls <package-name> | jq -r .version

Or, if you want to be verbose:

npm --json list <package-name> | jq --raw-output '.version'

For instance:

npm -j ls ghost | jq -r .version

Output:

0.4.2

Also, the JSON format is slightly different for global packages, so you'll need to change the query.

For instance:

npm -j -g ls | jq -r .dependencies.ghost.version

Output:

0.4.2
21

You can also check the version with this command:

npm info <package name> version

2
  • 45
    Again, it shows the latest version available in the package registry not the version of the currently installed package. Commented Apr 12, 2018 at 18:39
  • @DawidFerenczy Agree with its show only latest version like npm info httpaction
    – Nitin .
    Commented Nov 3, 2018 at 4:22
18

I've seen some very creative answers, but you can just do this (for global packages add the --global switch):

npm ls package

Example:

npm ls babel-cli

Output:

`-- [email protected]

The npm documentation says that npm -ls

This command will print to stdout all the versions of packages that are installed, as well as their dependencies, in a tree-structure.

NPM documentation

1
  • '..as well as their dependencies, in a tree-structure' - beware of structure hell (:
    – Neeraj
    Commented Oct 1, 2020 at 20:08
15

If you are brave enough (and have Node.js installed), you can always do something like:

echo "console.log(require('./package.json').version);" | node

This will print the version of the current package. You can also modify it to go insane, like this:

echo "eval('var result='+require('child_process').execSync('npm version',{encoding:'utf8'})); console.log(result.WHATEVER_PACKAGE_NAME);" | node

That will print the version of WHATEVER_PACKAGE_NAME package, that is seen by npm version.

1
  • 2
    node -e "console.log(require('./package.json').version);"
    – papiro
    Commented Nov 22, 2019 at 0:05
14

To see all the installed packages locally or globally, use these commands:

  1. npm list for local packages or npm list -g for globally installed packages.
  2. npm list --depth=0
  3. npm list | sls <package name>
  4. node -v
0
14

To list local packages with the version number use:

npm ls --depth=0

To list global packages with the version number use:

npm ls -g --depth=0

0
13

npm list --depth 0 is the command which shows all libraries with version, but you can use npm-check.

npm-check is a good library to manage all those things regarding the version system event. It will show libraries versions, new version updates, and unused versions, and many more.

To install it, just run:

npm install -g npm-check

And simply run

npm-check

Check the screenshot. It is showing everything about the package versions, new version updates, and unused versions.

Enter image description here

It works globally too. Give it a try.

12

I've built a tool that does exactly that - qnm.

qnm - A simple CLI utility for querying the node_modules directory.

Install it using:

npm i --global qnm

And run:

qnm [module]

For example:

qnm lodash

Output:

lodash
├── 4.17.5
├─┬ cli-table2
│ └── 3.10.1
└─┬ karma
  └── 3.10.1

Which means we have lodash installed in the root of the node_modules folder folder and two other copies in the node_modules folder of cli-table2 and karma.

It's really fast and has some nice features, like tab completion and match search.

11

npm list package-name gives the currently installed version

11

Try with:

npm list --depth 1 --global packagename
0
9

Here's a portable Unix (using grep and sed) one-liner that returns the version string of a globally-installed npm package (remove the g from -pg to query local packages instead):

npm ll -pg --depth=0 grunt | grep -o "@.*:" | sed 's/.$//; s/^.//'

Output:

0.4.5
  • the npm ll outputs a parsable string formatted like: /usr/lib/node_modules/npm:[email protected]:;
  • the grep command extracts the value between @ and :, inclusive;
  • the sed command removes the surrounding characters.
1
  • With newer versions of npm, there is no trailing colon, so the pipeline is just | grep -o "@.*" | sed 's/^.//'.
    – Bbrk24
    Commented Aug 22, 2023 at 4:43
7

I added this to my .bashrc file:

function npmv {
    case $# in # Number of arguments passed
    0) v="$(npm -v)" ; # Store output from npm -v in variable
        echo "NPM version is: $v"; # Can't use single quotes
                                   # ${v} would also work
    ;;
    1) s="$(npm list --depth=0 $1 | grep $1 | cut -d @ -f 2)";
       echo "$s";
    ;;
    2) case "$2" in # Second argument
        g) #global| # Syntax to compare bash string to literal
             s="$(npm list --depth=0 -g $1 | grep $1 | cut -d @ -f 2)";
        echo "$s";
        ;;
        l) #Latest
             npm view $1 version; # 'npm info $1 version' does the same thing
       ;;
       *) echo 'Invalid arguments';
       ;;
       esac;
    ;;
    *) echo 'Invalid arguments';
    ;;
    esac;
}
export -f npmv

Now all I have to do is type:

  • npmv for the version of npm, for example, NPM version is: 4.2.0
  • npmv <package-name> for the local version, for example, 0.8.08
  • npmv <package-name> g for global version, for example, 0.8.09
  • npmv <package-name> l for latest version, for example, 0.8.10

Note -d on the cut command means delimit by, followed by @, and then f means field. The '2' means the second field since there will be one either side of the @ symbol.

7

This is a simple question and should have a simpler answer than what I see in previous answers.

To see the installed npm packages with their version, the command is npm ls --depth=0, which, by default, displays what is installed locally. To see the globally installed packages, add the -global argument: npm ls --depth=0 -global.

--depth=0 returns a list of installed packages without their dependencies, which is what you're wanting to do most of the time.

ls is the name of the command, and list is an alias for ls.

6

If you'd like to check for a particular module installed globally, on Unix-like systems use:

npm list -g --depth=0 | grep <module_name>
5

To get only the installed version number, try:

npm list --depth=0 packagename | grep packagename | cut -d'@' -f2

E.g., the installed version number of PM2:

npm list --depth=0 pm2 | grep pm2 | cut -d'@' -f2

And to list globally installed packages, add the -g flag to the npm list command, eg:

npm list -g --depth=0 packagename | grep packagename | cut -d'@' -f2
1
  • For me -f3 instead of -f2, but otherwise works great!
    – coyotte508
    Commented Dec 7, 2023 at 13:49
4

I am using

npm list --depth=0 | grep module_name@

It brings me results like this:

[email protected]
4

Access the package.json file

You can access the package.json or bower.json file of the package with:

Windows (with notepad installed):

notepad ./node_modules/vue-template-compiler/package.json`

This will open the package.json in Notepad which has the version number of the packageName you included in the command.

Mac/Linux:

cat node_modules/prettier/package.json | grep version

This will output something like this:

screenshot of command output

3
  • 10
    Not only are there much easier ways to do this, the version you have specified in your package.json may not actually be the installed version due to semver range notations. That is, a dependency may be specified as version ^1.3.0, but that can mean anything from version 1.3.0 to 1.99.99 Commented Jun 14, 2017 at 14:29
  • On Windows only, presumably? What version / edition was this tried on? Please respond by editing (changing) your answer, not here in comments (without "Edit:", "Update:", or similar - the answer should appear as if it was written today). Commented Aug 11, 2022 at 19:38
  • Hi @PeterMortensen, I've update the answer with few more details. Hope this helps!!
    – Aakash
    Commented Aug 12, 2022 at 7:34
3

Run the following command to list the installed packages and their versions:

For a specific project (locally):

npm list

For a global package (globally installed):

npm list -g

If you want to find the version of a specific package, you can specify its name:

For a specific project (locally):

npm list <package-name>

For a global package (globally installed):

npm list -g <package-name>

This will display a tree-like structure of all the installed packages and their versions in your project or globally. Look for the package you're interested in, and its version should be displayed next to its name.

1
  • 1
    please do not write duplicated answer, many people already proposed that solution.
    – vdegenne
    Commented Jan 3 at 9:11
2

You may try this: npm show {package} version shows the latest package version. And if your package is outdated, npm outdated will show it with version info.

1
  • 8
    The OP was asking about the version of the currently installed package, not the latest version available in the package registry. Commented Apr 12, 2018 at 18:41
2

You can use npm view [module] version, npm info [module] version, npm show [module] version or npm v [module] version to check the version on an installed npm module.

Let's suppose my Grunt module version is the 0.4.5:

npm view grunt version => 0.4.5
npm info grunt version => 0.4.5
npm show grunt version => 0.4.5
npm v grunt version    => 0.4.5
1
  • 25
    All of those show the newest available version, not the currently installed version
    – sth
    Commented Sep 5, 2016 at 17:21

Not the answer you're looking for? Browse other questions tagged or ask your own question.