uuid vs node-uuid vs uuidv4 vs uuid-random
UUID Generation Libraries
Search packages..
uuidnode-uuiduuidv4uuid-randomSimilar Packages:
UUID Generation Libraries

UUID (Universally Unique Identifier) generation libraries in Node.js provide tools to create unique identifiers for various purposes, such as database keys, session IDs, or any scenario where a unique value is required. These libraries implement algorithms defined by the RFC 4122 standard to generate UUIDs, ensuring their uniqueness across different systems and time. They offer various methods to generate UUIDs, including version 1 (time-based), version 3 (name-based using MD5), version 4 (randomly generated), and version 5 (name-based using SHA-1). The choice of library may depend on factors like the desired UUID version, performance, ease of use, and additional features like namespace support or customizability.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
uuid176,938,09115,15366.7 kB22 months agoMIT
node-uuid979,734266-09 years ago-
uuidv4547,086-17.4 kB--MIT
uuid-random247,840104-15 years agoMIT
Feature Comparison: uuid vs node-uuid vs uuidv4 vs uuid-random

UUID Version Support

  • uuid:

    The uuid package supports all UUID versions (1, 3, 4, and 5) and provides a clear API for generating each type. It also includes utilities for creating UUIDs from strings, ensuring compliance with the RFC 4122 standard.

  • node-uuid:

    node-uuid supports multiple UUID versions, including 1, 3, 4, and 5, providing flexibility for different use cases. It allows developers to choose the appropriate version based on their requirements, whether they need time-based, name-based, or random UUIDs.

  • uuidv4:

    uuidv4 is dedicated to generating version 4 UUIDs, which are randomly generated. It offers a straightforward interface for creating UUIDs quickly, making it ideal for applications that require fast and frequent UUID generation.

  • uuid-random:

    uuid-random focuses exclusively on generating random UUIDs (version 4). It is a specialized tool for scenarios where only random UUIDs are needed, making it simple and efficient for that purpose.

Bundle Size

  • uuid:

    The uuid package is designed with efficiency in mind, and while it is feature-rich, it maintains a reasonable bundle size. This makes it a good choice for modern applications where performance and load times are considerations.

  • node-uuid:

    node-uuid has a moderate bundle size, which is acceptable for most applications. It provides a good balance between functionality and size, making it suitable for both small and large projects.

  • uuidv4:

    uuidv4 is also a lightweight package, optimized for generating version 4 UUIDs with minimal overhead. Its small size makes it suitable for applications that require quick and efficient UUID generation without adding significant bloat.

  • uuid-random:

    uuid-random is a lightweight package with a small bundle size, making it ideal for projects where minimizing load time and resource usage is critical. Its simplicity and focus on random UUIDs contribute to its efficiency.

Ease of Use

  • uuid:

    The uuid package offers a well-documented and intuitive API for generating UUIDs. Its clear documentation and examples make it easy for developers to understand and use the library effectively.

  • node-uuid:

    node-uuid provides a straightforward API for generating UUIDs, but its documentation may not be as comprehensive as newer libraries. However, its simplicity and reliability make it easy to use for quick implementations.

  • uuidv4:

    uuidv4 features a simple and clear API for generating version 4 UUIDs. Its focus on a single UUID version makes it easy to use and understand, particularly for developers who need a quick and efficient way to generate random UUIDs.

  • uuid-random:

    uuid-random has a simple API focused on generating random UUIDs. Its minimalistic design makes it easy to use, especially for projects that require a no-frills solution for UUID generation.

Performance

  • uuid:

    The uuid package is optimized for performance, especially when generating UUIDs. It is designed to handle high-frequency UUID generation without significant impact on application performance, making it suitable for scalable applications.

  • node-uuid:

    node-uuid performs well for generating UUIDs across different versions, but its performance may vary depending on the version being generated. Overall, it is efficient and suitable for most applications.

  • uuidv4:

    uuidv4 is optimized for generating version 4 UUIDs quickly. Its performance is excellent for applications that need to generate random UUIDs at scale, with minimal resource consumption and fast execution times.

  • uuid-random:

    uuid-random is highly efficient for generating random UUIDs (version 4) due to its focused functionality. Its lightweight design ensures fast UUID generation, making it ideal for applications that require quick and frequent random UUIDs.

Code Example

  • uuid:

    Generate a Random UUID with uuid

    const { v4: uuidv4 } = require('uuid');
const randomUUID = uuidv4();
console.log(randomUUID);
  • node-uuid:

    Generate a Random UUID with node-uuid

    const uuid = require('node-uuid');
const randomUUID = uuid.v4();
console.log(randomUUID);
  • uuidv4:

    Generate a Random UUID with uuidv4

    const { v4: uuidv4 } = require('uuid');
const randomUUID = uuidv4();
console.log(randomUUID);
  • uuid-random:

    Generate a Random UUID with uuid-random

    const uuidRandom = require('uuid-random');
const randomUUID = uuidRandom();
console.log(randomUUID);
How to Choose: uuid vs node-uuid vs uuidv4 vs uuid-random
  • uuid:

    Select uuid for a modern, feature-rich library that adheres to the latest standards. It offers a comprehensive API, including support for all UUID versions, and is actively maintained, making it suitable for new projects.

  • node-uuid:

    Choose node-uuid if you need a simple and reliable library for generating UUIDs, especially if you are working on a legacy project. It supports multiple UUID versions and is easy to integrate.

  • uuidv4:

    Use uuidv4 when you specifically need to generate version 4 UUIDs with a straightforward API. This package is optimized for generating random UUIDs quickly and is perfect for applications that require high-performance UUID generation.

  • uuid-random:

    Opt for uuid-random if you require a lightweight solution focused solely on generating random UUIDs (version 4). It has a minimal footprint and is ideal for projects where simplicity and performance are priorities.

Similar Npm Packages to uuid

uuid is a popular npm package used for generating universally unique identifiers (UUIDs). UUIDs are 128-bit numbers used to uniquely identify information in computer systems. The uuid package provides various methods for generating UUIDs according to different versions of the UUID standard, making it a versatile choice for developers needing unique identifiers in their applications. While uuid is widely used, there are several alternatives available that also serve the purpose of generating unique identifiers. Here are a few notable alternatives:

  • node-uuid was one of the original libraries for generating UUIDs in Node.js applications. It provided a simple interface for generating UUIDs but has since been deprecated in favor of the uuid package. While it still exists, developers are encouraged to use the uuid package for better support and updated features.
  • shortid is a library that generates short, unique, non-sequential ids. Unlike UUIDs, which are long and standardized, shortid produces shorter identifiers that are easier to read and use in URLs or as keys in databases. If your application requires unique identifiers that are compact and human-readable, shortid is a great alternative to consider.
  • uuidv4 is a specific implementation of UUID version 4, which generates random UUIDs. While uuidv4 is a simpler and more focused package compared to uuid, it is suitable for scenarios where you only need to generate version 4 UUIDs without the additional features provided by the uuid package. If your use case is straightforward and you only need random UUIDs, uuidv4 can be a lightweight option.

To explore how these packages compare, check out the comparison: Comparing node-uuid vs shortid vs uuid vs uuidv4.

Similar Npm Packages to node-uuid

node-uuid is a popular library for generating universally unique identifiers (UUIDs) in Node.js applications. It provides a straightforward API to create UUIDs that can be used for various purposes, such as database keys, session identifiers, and more. While node-uuid has been widely used, there are several alternatives available that offer similar functionality. Here are a few noteworthy alternatives:

  • uuid is a modern and widely adopted library for generating UUIDs in both Node.js and browser environments. It is a more recent implementation that adheres to the RFC4122 standard for UUIDs. The uuid library provides different methods for generating UUIDs, including version 1 (timestamp-based) and version 4 (randomly generated). Its flexibility and compliance with standards make it a preferred choice for developers looking for a reliable UUID generation solution.
  • uuid-random is a lightweight library focused solely on generating random UUIDs (version 4). It provides a simple API for generating UUIDs without the additional features or complexity found in other libraries. If you only need to generate random UUIDs and prefer a minimalistic approach, uuid-random is an excellent choice that keeps your dependencies light.
  • uuidv4 is another library specifically designed for generating version 4 UUIDs. It is a small and straightforward package that focuses on providing a simple method to create random UUIDs. If your application requires only version 4 UUIDs and you want a dedicated solution without any extra features, uuidv4 is a suitable option.

For a comprehensive comparison of these libraries, check out the following link: Comparing node-uuid vs uuid vs uuid-random vs uuidv4.

Similar Npm Packages to uuidv4

uuidv4 is a popular JavaScript library used for generating universally unique identifiers (UUIDs). Specifically, it generates UUIDs based on version 4 of the UUID standard, which creates random UUIDs. This is particularly useful in scenarios where unique identifiers are needed, such as in databases, session identifiers, or anywhere that requires a unique key. The simplicity and ease of use of uuidv4 make it a go-to choice for developers looking to generate unique identifiers quickly.

While uuidv4 is widely used, there are several alternatives that also provide UUID generation capabilities. Here are a few notable ones:

  • node-uuid is an earlier library for generating UUIDs in Node.js applications. It supports multiple UUID versions, including version 1 (timestamp-based) and version 4 (random). While it has been a popular choice in the past, it has since been deprecated in favor of the uuid library, which offers a more modern and comprehensive approach to UUID generation. If you're maintaining older codebases, you might still encounter node-uuid, but for new projects, it's better to use uuid.

  • short-uuid is a library that generates shorter, more URL-friendly UUIDs. It is particularly useful when you need unique identifiers that are compact and easy to read. short-uuid provides a simple API for generating these shorter UUIDs, which can be beneficial in applications where space is a concern, such as in URLs or when displaying IDs in user interfaces.

  • uuid is the modern replacement for node-uuid and is now the standard library for generating UUIDs in JavaScript. It supports all UUID versions and provides a robust set of features, including the ability to generate UUIDs in various formats. The uuid library is actively maintained and widely adopted, making it a reliable choice for developers looking for a comprehensive UUID solution.

For a detailed comparison of these packages, check out the following link: Comparing node-uuid vs short-uuid vs uuid vs uuidv4.

Similar Npm Packages to uuid-random

uuid-random is a simple and efficient npm package that generates random UUIDs (Universally Unique Identifiers). It is particularly useful for developers who need to create unique identifiers for objects, database entries, or any other purpose where uniqueness is critical. The package is lightweight and easy to use, making it a popular choice for generating UUIDs in JavaScript applications. However, there are several alternatives available that also provide similar functionality. Here are a few notable options:

  • crypto-random-string is a package that generates cryptographically strong random strings. While it is not specifically designed for UUIDs, it can be used to create unique identifiers of varying lengths and character sets. If you need more control over the format and length of the generated strings, crypto-random-string is a great choice. It is particularly useful for generating secure tokens or identifiers that require a higher level of randomness.
  • uuid is one of the most popular libraries for generating UUIDs in JavaScript. It provides a comprehensive set of functions to create UUIDs of different versions, including UUIDv1, UUIDv3, UUIDv4, and UUIDv5. The uuid package is widely adopted and well-maintained, making it a reliable choice for developers who need robust UUID generation capabilities. If you require different types of UUIDs or need to adhere to specific UUID standards, the uuid package is the best option.
  • uuidv4 is a lightweight package specifically designed for generating UUID version 4 (randomly generated UUIDs). It is a simple and straightforward solution for developers who only need to create UUIDv4 identifiers without the overhead of additional features. If your project only requires UUIDv4 and you prefer a minimalistic approach, uuidv4 is an excellent choice.

To explore how uuid-random compares with crypto-random-string, uuid, and uuidv4, check out the comparison: Comparing crypto-random-string vs uuid vs uuid-random vs uuidv4.

README for uuid

uuid CI Browser

For the creation of RFC9562 (formerly RFC4122) UUIDs

[!NOTE]

Starting with uuid@12 CommonJS is no longer supported. See implications and motivation for details.

Quickstart

1. Install

npm install uuid

2. Create a UUID

import { v4 as uuidv4 } from 'uuid';

uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'

For timestamp UUIDs, namespace UUIDs, and other options read on ...

API Summary

uuid.NILThe nil UUID string (all zeros)New in uuid@8.3
uuid.MAXThe max UUID string (all ones)New in uuid@9.1
uuid.parse()Convert UUID string to array of bytesNew in uuid@8.3
uuid.stringify()Convert array of bytes to UUID stringNew in uuid@8.3
uuid.v1()Create a version 1 (timestamp) UUID
uuid.v1ToV6()Create a version 6 UUID from a version 1 UUIDNew in uuid@10
uuid.v3()Create a version 3 (namespace w/ MD5) UUID
uuid.v4()Create a version 4 (random) UUID
uuid.v5()Create a version 5 (namespace w/ SHA-1) UUID
uuid.v6()Create a version 6 (timestamp, reordered) UUIDNew in uuid@10
uuid.v6ToV1()Create a version 1 UUID from a version 6 UUIDNew in uuid@10
uuid.v7()Create a version 7 (Unix Epoch time-based) UUIDNew in uuid@10
uuid.v8()"Intentionally left blank"
uuid.validate()Test a string to see if it is a valid UUIDNew in uuid@8.3
uuid.version()Detect RFC version of a UUIDNew in uuid@8.3

API

uuid.NIL

The nil UUID string (all zeros).

Example:

import { NIL as NIL_UUID } from 'uuid';

NIL_UUID; // ⇨ '00000000-0000-0000-0000-000000000000'

uuid.MAX

The max UUID string (all ones).

Example:

import { MAX as MAX_UUID } from 'uuid';

MAX_UUID; // ⇨ 'ffffffff-ffff-ffff-ffff-ffffffffffff'

uuid.parse(str)

Convert UUID string to array of bytes

strA valid UUID String
returnsUint8Array[16]
throwsTypeError if str is not a valid UUID

[!NOTE] Ordering of values in the byte arrays used by parse() and stringify() follows the left ↠ right order of hex-pairs in UUID strings. As shown in the example below.

Example:

import { parse as uuidParse } from 'uuid';

// Parse a UUID
uuidParse('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨
// Uint8Array(16) [
//   110, 192, 189, 127,  17,
//   192,  67, 218, 151,  94,
//    42, 138, 217, 235, 174,
//    11
// ]

uuid.stringify(arr[, offset])

Convert array of bytes to UUID string

arrArray-like collection of 16 values (starting from offset) between 0-255.
[offset = 0]Number Starting index in the Array
returnsString
throwsTypeError if a valid UUID string cannot be generated

[!NOTE] Ordering of values in the byte arrays used by parse() and stringify() follows the left ↠ right order of hex-pairs in UUID strings. As shown in the example below.

Example:

import { stringify as uuidStringify } from 'uuid';

const uuidBytes = Uint8Array.of(
  0x6e,
  0xc0,
  0xbd,
  0x7f,
  0x11,
  0xc0,
  0x43,
  0xda,
  0x97,
  0x5e,
  0x2a,
  0x8a,
  0xd9,
  0xeb,
  0xae,
  0x0b
);

uuidStringify(uuidBytes); // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'

uuid.v1([options[, buffer[, offset]]])

Create an RFC version 1 (timestamp) UUID

[options]Object with one or more of the following properties:
[options.node = (random) ]RFC "node" field as an Array[6] of byte values (per 4.1.6)
[options.clockseq = (random)]RFC "clock sequence" as a Number between 0 - 0x3fff
[options.msecs = (current time)]RFC "timestamp" field (Number of milliseconds, unix epoch)
[options.nsecs = 0]RFC "timestamp" field (Number of nanoseconds to add to msecs, should be 0-10,000)
[options.random = (random)]Array of 16 random bytes (0-255) used to generate other fields, above
[options.rng]Alternative to options.random, a Function that returns an Array of 16 random bytes (0-255)
[buffer]Uint8Array or Uint8Array subtype (e.g. Node.js Buffer). If provided, binary UUID is written into the array, starting at offset
[offset = 0]Number Index to start writing UUID bytes in buffer
returnsUUID String if no buffer is specified, otherwise returns buffer
throwsError if more than 10M UUIDs/sec are requested

[!NOTE] The default node id (the last 12 digits in the UUID) is generated once, randomly, on process startup, and then remains unchanged for the duration of the process.

[!NOTE] options.random and options.rng are only meaningful on the very first call to v1(), where they may be passed to initialize the internal node and clockseq fields.

Example:

import { v1 as uuidv1 } from 'uuid';

uuidv1(); // ⇨ '2c5ea4c0-4067-11e9-9b5d-ab8dfbbd4bed'

Example using options:

import { v1 as uuidv1 } from 'uuid';

const options = {
  node: Uint8Array.of(0x01, 0x23, 0x45, 0x67, 0x89, 0xab),
  clockseq: 0x1234,
  msecs: new Date('2011-11-01').getTime(),
  nsecs: 5678,
};
uuidv1(options); // ⇨ '710b962e-041c-11e1-9234-0123456789ab'

uuid.v1ToV6(uuid)

Convert a UUID from version 1 to version 6

import { v1ToV6 } from 'uuid';

v1ToV6('92f62d9e-22c4-11ef-97e9-325096b39f47'); // ⇨ '1ef22c49-2f62-6d9e-97e9-325096b39f47'

uuid.v3(name, namespace[, buffer[, offset]])

Create an RFC version 3 (namespace w/ MD5) UUID

API is identical to v5(), but uses "v3" instead.

[!IMPORTANT] Per the RFC, "If backward compatibility is not an issue, SHA-1 [Version 5] is preferred."

uuid.v4([options[, buffer[, offset]]])

Create an RFC version 4 (random) UUID

[options]Object with one or more of the following properties:
[options.random]Array of 16 random bytes (0-255)
[options.rng]Alternative to options.random, a Function that returns an Array of 16 random bytes (0-255)
[buffer]Uint8Array or Uint8Array subtype (e.g. Node.js Buffer). If provided, binary UUID is written into the array, starting at offset
[offset = 0]Number Index to start writing UUID bytes in buffer
returnsUUID String if no buffer is specified, otherwise returns buffer

Example:

import { v4 as uuidv4 } from 'uuid';

uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

Example using predefined random values:

import { v4 as uuidv4 } from 'uuid';

const v4options = {
  random: Uint8Array.of(
    0x10,
    0x91,
    0x56,
    0xbe,
    0xc4,
    0xfb,
    0xc1,
    0xea,
    0x71,
    0xb4,
    0xef,
    0xe1,
    0x67,
    0x1c,
    0x58,
    0x36
  ),
};
uuidv4(v4options); // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836'

uuid.v5(name, namespace[, buffer[, offset]])

Create an RFC version 5 (namespace w/ SHA-1) UUID

nameString | Array
namespaceString | Array[16] Namespace UUID
[buffer]Uint8Array or Uint8Array subtype (e.g. Node.js Buffer). If provided, binary UUID is written into the array, starting at offset
[offset = 0]Number Index to start writing UUID bytes in buffer
returnsUUID String if no buffer is specified, otherwise returns buffer

[!NOTE] The RFC DNS and URL namespaces are available as v5.DNS and v5.URL.

Example with custom namespace:

import { v5 as uuidv5 } from 'uuid';

// Define a custom namespace.  Readers, create your own using something like
// https://www.uuidgenerator.net/
const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';

uuidv5('Hello, World!', MY_NAMESPACE); // ⇨ '630eb68f-e0fa-5ecc-887a-7c7a62614681'

Example with RFC URL namespace:

import { v5 as uuidv5 } from 'uuid';

uuidv5('https://www.w3.org/', uuidv5.URL); // ⇨ 'c106a26a-21bb-5538-8bf2-57095d1976c1'

uuid.v6([options[, buffer[, offset]]])

Create an RFC version 6 (timestamp, reordered) UUID

This method takes the same arguments as uuid.v1().

import { v6 as uuidv6 } from 'uuid';

uuidv6(); // ⇨ '1e940672-c5ea-64c1-9bdd-2b0d7b3dcb6d'

Example using options:

import { v6 as uuidv6 } from 'uuid';

const options = {
  node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
  clockseq: 0x1234,
  msecs: new Date('2011-11-01').getTime(),
  nsecs: 5678,
};
uuidv6(options); // ⇨ '1e1041c7-10b9-662e-9234-0123456789ab'

uuid.v6ToV1(uuid)

Convert a UUID from version 6 to version 1

import { v6ToV1 } from 'uuid';

v6ToV1('1ef22c49-2f62-6d9e-97e9-325096b39f47'); // ⇨ '92f62d9e-22c4-11ef-97e9-325096b39f47'

uuid.v7([options[, buffer[, offset]]])

Create an RFC version 7 (random) UUID

[options]Object with one or more of the following properties:
[options.msecs = (current time)]RFC "timestamp" field (Number of milliseconds, unix epoch)
[options.random = (random)]Array of 16 random bytes (0-255) used to generate other fields, above
[options.rng]Alternative to options.random, a Function that returns an Array of 16 random bytes (0-255)
[options.seq = (random)]32-bit sequence Number between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value.
[buffer]Uint8Array or Uint8Array subtype (e.g. Node.js Buffer). If provided, binary UUID is written into the array, starting at offset
[offset = 0]Number Index to start writing UUID bytes in buffer
returnsUUID String if no buffer is specified, otherwise returns buffer

Example:

import { v7 as uuidv7 } from 'uuid';

uuidv7(); // ⇨ '01695553-c90c-745a-b76f-770d7b3dcb6d'

uuid.v8()

"Intentionally left blank"

[!NOTE] Version 8 (experimental) UUIDs are "for experimental or vendor-specific use cases". The RFC does not define a creation algorithm for them, which is why this package does not offer a v8() method. The validate() and version() methods do work with such UUIDs, however.

uuid.validate(str)

Test a string to see if it is a valid UUID

strString to validate
returnstrue if string is a valid UUID, false otherwise

Example:

import { validate as uuidValidate } from 'uuid';

uuidValidate('not a UUID'); // ⇨ false
uuidValidate('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ true

Using validate and version together it is possible to do per-version validation, e.g. validate for only v4 UUIds.

import { version as uuidVersion } from 'uuid';
import { validate as uuidValidate } from 'uuid';

function uuidValidateV4(uuid) {
  return uuidValidate(uuid) && uuidVersion(uuid) === 4;
}

const v1Uuid = 'd9428888-122b-11e1-b85c-61cd3cbb3210';
const v4Uuid = '109156be-c4fb-41ea-b1b4-efe1671c5836';

uuidValidateV4(v4Uuid); // ⇨ true
uuidValidateV4(v1Uuid); // ⇨ false

uuid.version(str)

Detect RFC version of a UUID

strA valid UUID String
returnsNumber The RFC version of the UUID
throwsTypeError if str is not a valid UUID

Example:

import { version as uuidVersion } from 'uuid';

uuidVersion('45637ec4-c85f-11ea-87d0-0242ac130003'); // ⇨ 1
uuidVersion('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ 4

[!NOTE] This method returns 0 for the NIL UUID, and 15 for the MAX UUID.

Command Line

UUIDs can be generated from the command line using uuid.

$ npx uuid
ddeb27fb-d9a0-4624-be4d-4615062daed4

The default is to generate version 4 UUIDS, however the other versions are supported. Type uuid --help for details:

$ npx uuid --help

Usage:
  uuid
  uuid v1
  uuid v3 <name> <namespace uuid>
  uuid v4
  uuid v5 <name> <namespace uuid>
  uuid v7
  uuid --help

Note: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs
defined by RFC9562

options Handling for Timestamp UUIDs

Prior to uuid@11, it was possible for options state to interfere with the internal state used to ensure uniqueness of timestamp-based UUIDs (the v1(), v6(), and v7() methods). Starting with uuid@11, this issue has been addressed by using the presence of the options argument as a flag to select between two possible behaviors:

  • Without options: Internal state is utilized to improve UUID uniqueness.
  • With options: Internal state is NOT used and, instead, appropriate defaults are applied as needed.

Support

Browsers: uuid builds are tested against the latest version of desktop Chrome, Safari, Firefox, and Edge. Mobile versions of these same browsers are expected to work but aren't currently tested.

Node: uuid builds are tested against node (LTS releases), plus one prior. E.g. At the time of this writing node@20 is the "maintenance" release and node@24 is the "current" release, so uuid supports node@18-node@24.

Typescript: TS versions released within the past two years are supported. source

Known issues

"getRandomValues() not supported"

This error occurs in environments where the standard crypto.getRandomValues() API is not supported. This issue can be resolved by adding an appropriate polyfill:

React Native / Expo

  1. Install react-native-get-random-values
  2. Import it before uuid. Since uuid might also appear as a transitive dependency of some other imports it's safest to just import react-native-get-random-values as the very first thing in your entry point:
import 'react-native-get-random-values';
import { v4 as uuidv4 } from 'uuid';

Markdown generated from README_js.md by

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.