uuid vs nanoid vs uuidv4 vs short-uuid vs react-native-uuid vs react-uuid
UUID and Unique ID Generation Comparison
3 Years
uuidnanoiduuidv4short-uuidreact-native-uuidreact-uuidSimilar Packages:
What's UUID and Unique ID Generation?

UUID (Universally Unique Identifier) and unique ID generation libraries in JavaScript provide developers with tools to create unique identifiers for various purposes, such as database keys, session IDs, or any scenario where a distinct value is required. These libraries implement different algorithms to ensure the generated IDs are unique across time and space, minimizing the risk of collisions. They vary in size, performance, and features, making it essential for developers to choose the right one based on their project requirements. For instance, uuid is a widely used library that follows the RFC 4122 standard for UUID generation, while nanoid offers a smaller, faster alternative with customizable alphabet and length, making it ideal for performance-sensitive applications.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
uuid167,892,501
15,07266.7 kB13 days agoMIT
nanoid66,903,510
26,08412.1 kB36 months agoMIT
uuidv4533,835
-17.4 kB--MIT
short-uuid445,635
50472.9 kB5a year agoMIT
react-native-uuid253,798
285160 kB110 months agoMIT
react-uuid62,665
85.75 kB2-MIT
Feature Comparison: uuid vs nanoid vs uuidv4 vs short-uuid vs react-native-uuid vs react-uuid

ID Generation Method

  • uuid:

    uuid generates UUIDs using various algorithms, including version 1 (timestamp-based) and version 4 (randomly generated). It is a comprehensive library that supports multiple UUID versions and is compliant with the RFC 4122 standard.

  • nanoid:

    nanoid generates unique IDs using a secure random number generator and allows customization of the ID length and character set. This makes it both fast and secure, with a low risk of collisions even for shorter IDs.

  • uuidv4:

    uuidv4 generates version 4 UUIDs using a random number generator. It is a simple and focused library that provides a straightforward implementation for generating randomly generated UUIDs.

  • short-uuid:

    short-uuid generates shorter unique IDs by encoding UUIDs in a more compact format. It uses a customizable alphabet and allows for shorter ID generation while maintaining a low risk of collisions, making it ideal for space-constrained applications.

  • react-native-uuid:

    react-native-uuid generates UUIDs using a combination of random values and the current timestamp, ensuring a high degree of uniqueness. It follows the UUID standard, making it suitable for applications that require compliant identifiers.

  • react-uuid:

    react-uuid generates UUIDs using the built-in crypto module in modern browsers, providing a simple and efficient way to create unique identifiers. It is lightweight and does not require any external dependencies.

Customization

  • uuid:

    uuid provides some customization, such as the ability to generate UUIDs of different versions. However, it primarily focuses on adhering to the UUID standard, which limits the extent of customization available.

  • nanoid:

    nanoid offers extensive customization options, including the ability to change the ID length and character set. This flexibility allows developers to generate IDs that meet specific requirements for their applications.

  • uuidv4:

    uuidv4 is focused on generating version 4 UUIDs and does not provide customization options beyond that. It is a straightforward implementation that prioritizes simplicity and compliance with the UUID standard.

  • short-uuid:

    short-uuid allows customization of the ID length and character set, enabling developers to generate shorter IDs that are still unique. This feature is particularly useful for applications that need to display or store IDs in a more compact format.

  • react-native-uuid:

    react-native-uuid provides limited customization, as it primarily focuses on generating standard UUIDs. However, it is designed to be simple and easy to use, with a clear API for generating UUIDs quickly.

  • react-uuid:

    react-uuid does not offer much customization, as it generates UUIDs based on the standard algorithm. It is designed to be lightweight and efficient, prioritizing simplicity over configurability.

Bundle Size

  • uuid:

    uuid is a well-established library, but it is larger than some of the newer ID generation libraries. While it provides comprehensive functionality, developers should be aware of its impact on bundle size when including it in their projects.

  • nanoid:

    nanoid is known for its small bundle size, especially compared to traditional UUID libraries. This makes it a great choice for performance-sensitive applications where minimizing load times is important.

  • uuidv4:

    uuidv4 is a lightweight library focused solely on generating version 4 UUIDs. Its small size makes it a good choice for projects that only need this specific type of UUID without any additional features.

  • short-uuid:

    short-uuid has a small bundle size, especially when compared to libraries that generate full-length UUIDs. Its compact design makes it a good choice for applications that need to conserve bandwidth and resources.

  • react-native-uuid:

    react-native-uuid has a relatively small bundle size, making it suitable for mobile applications where resources are limited. It is lightweight and does not add significant overhead to the app.

  • react-uuid:

    react-uuid is a lightweight library with a small bundle size, making it ideal for front-end projects where performance and load times are a concern. Its simplicity and efficiency contribute to its minimal impact on application size.

Ease of Use: Code Examples

  • uuid:

    Generate a UUID with uuid

    import { v4 as uuidv4 } from 'uuid';
    const id = uuidv4();
    console.log(id); // Example output: '550e8400-e29b-41d4-a716-446655440000'
    
  • nanoid:

    Generate a unique ID with nanoid

    import { nanoid } from 'nanoid';
    const id = nanoid();
    console.log(id); // Example output: 'V1StGXR8_Z5jdHi6B5q' 
    
  • uuidv4:

    Generate a version 4 UUID with uuidv4

    import { v4 as uuidv4 } from 'uuid';
    const id = uuidv4();
    console.log(id); // Example output: '550e8400-e29b-41d4-a716-446655440000'
    
  • short-uuid:

    Generate a short unique ID with short-uuid

    import ShortUUID from 'short-uuid';
    const shortUUID = ShortUUID.generate();
    console.log(shortUUID); // Example output: '3s8f9g'
    
  • react-native-uuid:

    Generate a UUID with react-native-uuid

    import uuid from 'react-native-uuid';
    const id = uuid.v4();
    console.log(id); // Example output: '550e8400-e29b-41d4-a716-446655440000'
    
  • react-uuid:

    Generate a UUID with react-uuid

    import { v4 as uuidv4 } from 'react-uuid';
    const id = uuidv4();
    console.log(id); // Example output: '550e8400-e29b-41d4-a716-446655440000'
    
How to Choose: uuid vs nanoid vs uuidv4 vs short-uuid vs react-native-uuid vs react-uuid
  • uuid:

    Choose uuid if you require a comprehensive and standards-compliant solution for generating UUIDs. It supports multiple UUID versions and is widely used in the industry, making it a reliable choice for any application.

  • nanoid:

    Choose nanoid if you need a fast, secure, and compact unique ID generator. It is particularly suitable for applications where performance and ID length are critical, such as in databases or when generating IDs on the fly.

  • uuidv4:

    Choose uuidv4 if you specifically need to generate version 4 UUIDs (randomly generated). It is a simple and efficient option for projects that only require this specific type of UUID.

  • short-uuid:

    Choose short-uuid if you need to generate shorter, URL-friendly unique IDs while maintaining a low risk of collisions. It is useful for applications where space is a concern, such as in URLs or when displaying IDs to users.

  • react-native-uuid:

    Choose react-native-uuid if you are working on a React Native project and need a simple solution for generating UUIDs. It provides a straightforward API and is optimized for mobile environments.

  • react-uuid:

    Choose react-uuid if you want a lightweight and easy-to-use library for generating UUIDs in React applications. It is designed to be simple and efficient, making it a great choice for front-end projects.

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.NIL | The nil UUID string (all zeros) | New in uuid@8.3 | | uuid.MAX | The max UUID string (all ones) | New in uuid@9.1 | | uuid.parse() | Convert UUID string to array of bytes | New in uuid@8.3 | | uuid.stringify() | Convert array of bytes to UUID string | New in uuid@8.3 | | uuid.v1() | Create a version 1 (timestamp) UUID | | | uuid.v1ToV6() | Create a version 6 UUID from a version 1 UUID | New 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) UUID | New in uuid@10 | | uuid.v6ToV1() | Create a version 1 UUID from a version 6 UUID | New in uuid@10 | | uuid.v7() | Create a version 7 (Unix Epoch time-based) UUID | New in uuid@10 | | ~~uuid.v8()~~ | "Intentionally left blank" | | | uuid.validate() | Test a string to see if it is a valid UUID | New in uuid@8.3 | | uuid.version() | Detect RFC version of a UUID | New 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

| | | | --------- | ---------------------------------------- | | str | A valid UUID String | | returns | Uint8Array[16] | | throws | TypeError 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

| | | | -------------- | ---------------------------------------------------------------------------- | | arr | Array-like collection of 16 values (starting from offset) between 0-255. | | [offset = 0] | Number Starting index in the Array | | returns | String | | throws | TypeError 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 | | returns | UUID String if no buffer is specified, otherwise returns buffer | | throws | Error 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 | | returns | UUID 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

| | | | --- | --- | | name | String \| Array | | namespace | String \| 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 | | returns | UUID 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 | | returns | UUID 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

| | | | --------- | --------------------------------------------------- | | str | String to validate | | returns | true 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

| | | | --------- | ---------------------------------------- | | str | A valid UUID String | | returns | Number The RFC version of the UUID | | throws | TypeError 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