uuid

Generate RFC-compliant UUIDs in JavaScript

14,576

897

14,576

View on GitHub View on NPM

Top Related Projects

uuid

12,455

:snowflake: A PHP library for generating universally unique identifiers (UUIDs).

nanoid

24,796

A tiny (124 bytes), secure, URL-friendly, unique string ID generator for JavaScript

Quick Overview

UUID.js is a JavaScript library for generating and working with Universally Unique Identifiers (UUIDs). It provides a simple and efficient way to create RFC4122 version 1, 3, 4, and 5 UUIDs in both browser and Node.js environments.

Pros

Cross-platform compatibility (works in browsers and Node.js)
Supports multiple UUID versions (v1, v3, v4, v5)
Lightweight and has zero dependencies
Well-maintained and actively developed

Cons

Limited to UUID-specific functionality
May be overkill for simple projects that only need basic unique ID generation
Requires understanding of UUID concepts for optimal usage

Code Examples

Generating a random UUID (v4):

import { v4 as uuidv4 } from 'uuid';

const id = uuidv4();
console.log(id); // e.g., '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

Creating a name-based UUID (v5):

import { v5 as uuidv5 } from 'uuid';

const namespace = '1b671a64-40d5-491e-99b0-da01ff1f3341';
const name = 'Hello, World!';
const id = uuidv5(name, namespace);
console.log(id); // Always '630eb68f-e0fa-5ecc-887a-7c7a62614681' for this input

Parsing and validating a UUID:

import { parse, validate } from 'uuid';

const myUUID = '416ac246-e7ac-49ff-93b4-f7e94d997e6b';

if (validate(myUUID)) {
  console.log('Valid UUID');
  const parsed = parse(myUUID);
  console.log(parsed); // Uint8Array(16) [65, 106, 194, 70, 231, 172, 73, 255, 147, 180, 247, 233, 77, 153, 126, 107]
} else {
  console.log('Invalid UUID');
}

Getting Started

To use UUID.js in your project, first install it via npm:

npm install uuid

Then, import and use the desired UUID functions in your JavaScript code:

import { v4 as uuidv4 } from 'uuid';

// Generate a random UUID
const id = uuidv4();
console.log(id);

// Use in your application as needed
const user = {
  id: uuidv4(),
  name: 'John Doe',
  email: 'john@example.com'
};

For more advanced usage and different UUID versions, refer to the library's documentation.

Competitor Comparisons

uuid

12,455

:snowflake: A PHP library for generating universally unique identifiers (UUIDs).

Pros of ramsey/uuid

More comprehensive UUID implementation, supporting all RFC 4122 versions (1, 2, 3, 4, 5)
Provides additional features like time-based UUIDs and namespace UUIDs
Offers better integration with PHP frameworks and ecosystems

Cons of ramsey/uuid

Larger library size, which may impact performance in some scenarios
More complex API, potentially requiring a steeper learning curve
PHP-specific, limiting its use to PHP environments

Code Comparison

ramsey/uuid:

use Ramsey\Uuid\Uuid;

$uuid = Uuid::uuid4();
echo $uuid->toString();

uuid:

import { v4 as uuidv4 } from 'uuid';

const uuid = uuidv4();
console.log(uuid);

Summary

ramsey/uuid is a more feature-rich UUID library for PHP, offering support for all RFC 4122 versions and additional functionality. However, it comes with a larger footprint and more complexity. uuid, on the other hand, is a lightweight JavaScript library focused on simplicity and ease of use, but with fewer features. The choice between the two depends on the specific requirements of your project, the programming language used, and the need for additional UUID functionality beyond basic generation.

nanoid

24,796

A tiny (124 bytes), secure, URL-friendly, unique string ID generator for JavaScript

Pros of nanoid

Significantly smaller bundle size (130 bytes vs. 4KB for uuid)
Faster generation of IDs
Customizable alphabet and ID length

Cons of nanoid

Less widely adopted compared to uuid
Doesn't offer specific UUID versions (v1, v4, etc.)
May not be suitable for applications requiring strict UUID compliance

Code Comparison

nanoid:

import { nanoid } from 'nanoid'
const id = nanoid() // => "V1StGXR8_Z5jdHi6B-myT"

uuid:

import { v4 as uuidv4 } from 'uuid'
const id = uuidv4() // => "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed"

Summary

nanoid is a lightweight, fast alternative to uuid, offering smaller bundle size and customizable ID generation. However, it lacks the specific UUID versions and widespread adoption of uuid. Choose nanoid for projects prioritizing performance and size, while uuid remains the standard for applications requiring strict UUID compliance or specific versions.

ksuid

4,968

K-Sortable Globally Unique IDs

Pros of KSUID

Time-sortable: KSUIDs include a timestamp, making them naturally sortable by creation time
Longer lifespan: 160-bit identifiers provide a much longer collision-free period compared to UUIDs
Human-readable: Base62 encoding makes KSUIDs more readable and easier to share verbally

Cons of KSUID

Less widely adopted: UUID is a more established standard with broader support across systems and languages
Larger size: KSUIDs are typically longer than UUIDs, which may impact storage efficiency in some cases
Not a formal standard: Unlike UUID, KSUID is not an official standard, potentially limiting interoperability

Code Comparison

uuid:

import { v4 as uuidv4 } from 'uuid';
const id = uuidv4();
console.log(id); // e.g., '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

ksuid:

import ksuid from 'ksuid';
const id = await ksuid.random();
console.log(id.string); // e.g., '0o5Fs0EELR0fUjHjbCnEtdUwQe3'

Both libraries provide simple ways to generate unique identifiers, but KSUID offers additional features like time-sorting and longer lifespan at the cost of less widespread adoption and slightly more complex usage.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

uuid

For the creation of RFC9562 (formally RFC4122) UUIDs

Complete - Support for all RFC9562 UUID versions
Cross-platform - Support for...
- ESM & Common JS
- Chrome, Safari, Firefox, Edge browsers
- NodeJS
- React Native / Expo
Secure - Cryptographically-strong random values
Compact - No dependencies, tree-shakable
CLI - Includes the uuid command line utility
Typescript - Types now included

[!NOTE] w> uuid@11 is now available: See the CHANGELOG for details. TL;DR:

TypeScript support is now included (remove @types/uuid from your dependencies)

Subtle changes to how the options arg is interpreted for v1(), v6(), and v7(). See details

Binary UUIDs are now Uint8Arrays. (May impact callers of parse(), stringify(), or that pass an option#buf argument to v1()-v7().)

Quickstart

1. Install

npm install uuid

2. Create a UUID

ESM-syntax (must use named exports):

import { v4 as uuidv4 } from 'uuid';
uuidv4(); // â¨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'

... CommonJS:

const { v4: uuidv4 } = require('uuid');
uuidv4(); // â¨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

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`]	`Array \| Buffer` If specified, uuid will be written here in byte-form, 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-9bdd-2b0d7b3dcb6d'

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`]	`Array \| Buffer` If specified, uuid will be written here in byte-form, 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(); // â¨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'

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`]	`Array \| Buffer` If specified, uuid will be written here in byte-form, 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-64c0-9b5d-ab8dfbbd4bed'

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`]	`Array \| Buffer` If specified, uuid will be written here in byte-form, 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-705a-b56d-778dfbbd4bed'

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. node@18 is in maintainence mode, and node@22 is the current LTS release. So uuid supports node@16-node@22.

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. 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

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Code Examples

Getting Started

Competitor Comparisons

Pros of ramsey/uuid

Cons of ramsey/uuid

Code Comparison

Summary

Pros of nanoid

Cons of nanoid

Code Comparison

Summary

Pros of KSUID

Cons of KSUID

Code Comparison

Convert designs to code with AI

README

uuid

Quickstart

API Summary

API

uuid.NIL

uuid.MAX

uuid.parse(str)

uuid.stringify(arr[, offset])

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

uuid.v1ToV6(uuid)

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

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

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

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

uuid.v6ToV1(uuid)

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

uuid.v8()

uuid.validate(str)

uuid.version(str)

Command Line

options Handling for Timestamp UUIDs

Support

Known issues

"getRandomValues() not supported"

React Native / Expo

Top Related Projects

Convert designs to code with AI

NPM DownloadsLast 30 Days

`options` Handling for Timestamp UUIDs