Generating Unique Identifiers in JavaScript and React
This comparison evaluates six popular npm packages used for generating unique identifiers (IDs) in web and mobile applications. It covers the industry-standard uuid, the modern and compact nanoid, platform-specific solutions like react-native-uuid, utility wrappers such as react-uuid and uuidv4, and translation tools like short-uuid. The analysis focuses on API design, security, bundle impact, and suitability for different environments like Node.js, browsers, and React Native.
Npm Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Generating Unique Identifiers: UUIDs, NanoIDs, and Short Codes
When building distributed systems or frontend applications, generating unique IDs is a common requirement. Whether you need database keys, session tokens, or URL slugs, the choice of library impacts security, bundle size, and compatibility. This deep dive compares six popular packages to help you choose the right tool for your architecture.
🆔 Core ID Generation: Standards vs Modern Alternatives
The most critical decision is between the industry-standard uuid and the modern nanoid. Both generate unique strings, but they differ in format, size, and underlying algorithm.
uuid implements the RFC 4122 standard. It produces 36-character strings (like 123e4567-e89b-12d3-a456-426614174000). It is heavily tested and trusted in enterprise environments.
// uuid: Standard RFC 4122 v4
import { v4 as uuidv4 } from 'uuid';
const id = uuidv4();
// Output: "550e8400-e29b-41d4-a716-446655440000"
nanoid uses a secure random generator and a URL-friendly alphabet. It produces shorter strings (21 characters by default) without special characters like hyphens.
// nanoid: Modern, URL-friendly
import { nanoid } from 'nanoid';
const id = nanoid();
// Output: "V1StGXR8_Z5jdHi6B-myT"
uuidv4 is a legacy package that solely generates v4 UUIDs. It exists primarily for historical reasons before the main uuid package modularized its exports.
// uuidv4: Legacy wrapper
import uuidv4 from 'uuidv4';
const id = uuidv4();
// Output: "550e8400-e29b-41d4-a716-446655440000"
react-uuid is a thin wrapper designed for React projects, though it offers no technical benefit over using uuid directly.
// react-uuid: Unnecessary wrapper
import { v4 as uuidv4 } from 'react-uuid';
const id = uuidv4();
// Output: "550e8400-e29b-41d4-a716-446655440000"
📏 Length and URL Safety
ID length affects database storage, URL readability, and collision probability. nanoid and short-uuid specialize in compact representations.
nanoid is inherently shorter and URL-safe by default. It avoids characters that need encoding in URLs.
// nanoid: Custom length example
import { nanoid } from 'nanoid';
const shortId = nanoid(10);
// Output: "IRFa-VaY2b" (10 chars)
short-uuid does not generate new IDs from scratch. Instead, it translates existing standard UUIDs into shorter strings using a custom alphabet (like base58).
// short-uuid: Translate standard UUID to short
import short from 'short-uuid';
const translator = short();
const standardId = "550e8400-e29b-41d4-a716-446655440000";
const shortId = translator.fromUUID(standardId);
// Output: "2Jgq5cZ7V9kH1bN8mP3r"
uuid and uuidv4 always produce the standard 36-character format. They are not URL-safe without encoding due to hyphens.
// uuid: Standard length
import { v4 } from 'uuid';
const id = v4();
// Output: "550e8400-e29b-41d4-a716-446655440000" (36 chars)
📱 Platform Specifics: React Native
React Native environments sometimes lack native crypto modules required for secure random generation. Specific packages handle this polyfilling.
react-native-uuid is built to work around React Native limitations. It ensures secure generation without crashing on mobile devices.
// react-native-uuid: Mobile optimized
import uuid from 'react-native-uuid';
const id = uuid.v4();
// Output: "550e8400-e29b-41d4-a716-446655440000"
nanoid also works in React Native but may require async usage or polyfills depending on the version and bundler configuration.
// nanoid: Async usage in restricted environments
import { nanoid } from 'nanoid/async';
const id = await nanoid();
// Output: "V1StGXR8_Z5jdHi6B-myT"
uuid can work in React Native but often requires additional setup for crypto polyfills compared to react-native-uuid.
// uuid: May require polyfills in RN
import { v4 } from 'uuid';
const id = v4();
// Output: "550e8400-e29b-41d4-a716-446655440000"
⚠️ Legacy and Wrapper Packages
Some packages exist primarily for backward compatibility or convenience but add little value today.
uuidv4 is functionally identical to importing v4 from uuid. Using the separate package introduces an extra dependency without extra features.
// uuidv4: Redundant import
import uuidv4 from 'uuidv4';
// Recommendation: Use import { v4 } from 'uuid' instead
react-uuid suggests React needs a special UUID tool, which is false. UUID generation is pure JavaScript.
// react-uuid: Unnecessary abstraction
import { v4 } from 'react-uuid';
// Recommendation: Use import { v4 } from 'uuid' instead
🔒 Security and Entropy
For security-sensitive IDs (like password reset tokens), cryptographic strength matters.
nanoid uses crypto.randomBytes in Node.js and crypto.getRandomValues in browsers. It is secure by default.
// nanoid: Secure by default
import { nanoid } from 'nanoid';
// Uses secure random generator internally
uuid v4 also uses secure random generation. It is audited and trusted for security-critical systems.
// uuid: Secure v4
import { v4 } from 'uuid';
// Compliant with RFC 4122 security requirements
react-native-uuid ensures the same security standards but adapts the underlying random source for mobile OS compatibility.
// react-native-uuid: Secure on mobile
import uuid from 'react-native-uuid';
// Handles mobile crypto constraints securely
📊 Summary Table
| Package | Format | Length | URL Safe | React Native | Status |
|---|---|---|---|---|---|
uuid | RFC 4122 | 36 chars | ❌ (hyphens) | ⚠️ (setup) | ✅ Standard |
nanoid | Alphanumeric | 21 chars | ✅ | ✅ (async) | ✅ Modern |
short-uuid | Base58/64 | ~22 chars | ✅ | ✅ | ✅ Utility |
react-native-uuid | RFC 4122 | 36 chars | ❌ (hyphens) | ✅ Native | ✅ Mobile |
react-uuid | RFC 4122 | 36 chars | ❌ (hyphens) | ✅ | ⚠️ Avoid |
uuidv4 | RFC 4122 | 36 chars | ❌ (hyphens) | ⚠️ (setup) | ⚠️ Legacy |
💡 Final Recommendation
For most modern web applications, nanoid is the best default choice. It is smaller, URL-friendly, and secure. Use uuid if you need strict RFC compliance or interoperability with legacy systems. For React Native projects without crypto polyfills, react-native-uuid saves configuration time. Avoid react-uuid and uuidv4 as they add dependencies without solving new problems. Use short-uuid only when you must display standard UUIDs in a compact format.
How to Choose: uuid vs nanoid vs short-uuid vs react-native-uuid vs uuidv4 vs react-uuid
- uuid:
Choose
uuidfor enterprise-grade applications requiring strict RFC 4122 compliance. It is the industry standard, widely audited, and supports multiple versions (v1, v4, v7). Best for backend services, database keys, and systems where interoperability is critical. - nanoid:
Choose
nanoidfor modern web applications where bundle size and URL safety are priorities. It is secure, fast, and generates shorter IDs than standard UUIDs by default. Ideal for public-facing URLs, document IDs, and general-purpose unique keys in frontend-heavy projects. - short-uuid:
Choose
short-uuidwhen you need to store standard UUIDs but display or transmit them in a shorter format. It translates between standard UUIDs and compact strings (like base58), useful for user-facing codes where length matters. - react-native-uuid:
Choose
react-native-uuidspecifically when working in React Native environments that lack native crypto modules. It provides a polyfilled solution to ensure UUID generation works consistently across iOS and Android without additional configuration. - uuidv4:
Avoid
uuidv4in new projects. This package is largely redundant because the mainuuidpackage exports v4 functionality directly. It is less maintained and offers no advantage over importingv4from the canonicaluuidpackage. - react-uuid:
Avoid
react-uuidin new projects. It is a thin wrapper around existing UUID libraries that adds unnecessary dependencies. Useuuidornanoiddirectly instead, as they work perfectly in React without special wrappers.
Popular Comparisons
README for uuid
uuid 
For the creation of RFC9562 (formerly RFC4122) UUIDs
- Complete - Support for all RFC9562 UUID versions
- Cross-platform - Support for...
- Secure - Uses modern
cryptoAPI for random values - Compact - Zero-dependency, tree-shakable
- CLI -
uuidcommand line utility
[!NOTE]
Starting with
uuid@12CommonJS 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(); // ⇨ 'b18794e8-5d0d-417c-b361-ba38e78411b4'
For timestamp UUIDs, namespace UUIDs, and other options read on ...
API Summary
uuid.NIL | The nil UUID string (all zeros) |
uuid.MAX | The max UUID string (all ones) |
uuid.parse() | Convert UUID string to array of bytes |
uuid.stringify() | Convert array of bytes to UUID string |
uuid.v1() | Generate a version 1 (timestamp) UUID |
uuid.v1ToV6() | Convert a version 1 UUID to version 6 |
uuid.v3() | Generate a version 3 (namespace w/ MD5) UUID |
uuid.v4() | Generate a version 4 (random) UUID |
uuid.v5() | Generate a version 5 (namespace w/ SHA-1) UUID |
uuid.v6() | Generate a version 6 (timestamp, reordered) UUID |
uuid.v6ToV1() | Convert a version 6 UUID to version 1 |
uuid.v7() | Generate a version 7 (Unix Epoch time-based) UUID |
uuid.v8() | "Intentionally left blank" |
uuid.validate() | Test a string to see if it is a valid UUID |
uuid.version() | Detect RFC version of a UUID |
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()andstringify()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()andstringify()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 |
Example:
import { v1 as uuidv1 } from 'uuid';
uuidv1(); // ⇨ '57fd0000-c7d3-11ef-841d-514d2167fc5b'
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(); // ⇨ 'b18794e8-5d0d-417c-b361-ba38e78411b4'
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
DNSandURLnamespaces are available asv5.DNSandv5.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(); // ⇨ '1efc7d35-7fd0-6000-841d-504d2167fc5b'
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(); // ⇨ '01941f29-7c00-73e4-a310-744d2167fc5b'
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. Thevalidate()andversion()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
0for theNILUUID, and15for theMAXUUID.
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@20-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
- Install
react-native-get-random-values - Import it before
uuid. Sinceuuidmight also appear as a transitive dependency of some other imports it's safest to just importreact-native-get-random-valuesas the very first thing in your entry point:
import 'react-native-get-random-values';
import { v4 as uuidv4 } from 'uuid';
Generated from README_js.md by runmd