How is CUID2 different from CUID v1?

CUID2 drops the time-leak of v1 (no easily readable timestamp prefix), uses a SHA3-based mixing function, and is designed to be 24 characters of base36.

Is CUID2 sortable by creation time?

No — sortability was intentionally removed. If you need k-sortable IDs use KSUID or ULID instead.

What are the collision odds?

CUID2 is designed for cryptographically random distributions across the 24-character base36 space; collision risk in any realistic workload is negligible.

Where are IDs generated?

Entirely in your browser using crypto.getRandomValues. No part of the ID is fetched or logged.

cuid2 · 24-char · collision-resistant · local

Generate CUID2 short IDs

Time-based + random + per-host fingerprint = short, sortable, collision-resistant identifiers. Web Crypto powered.

CUID2 Generator

Count

10 requested

Length

chars

Output

0 B

txt

Status

—

web crypto

input · controls

Fingerprint: 3p5jxwvt

CUID2 prefixes with 'c', then encodes the timestamp, a counter, fresh entropy, and an 8-char host fingerprint. The output is base36 lowercase.

Tap New fingerprint to simulate another host — useful for testing distributed ID generation.

output · cuid2 (0)

Click Generate to mint CUIDs

Quick Start

How CUID2 works

CUID2 is the modern successor to CUID. It is short, URL-safe, k-sortable by timestamp, and collision-resistant across distributed hosts.

01
Pick a count
1 to 100 IDs per click.
Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.
countUTF-8TextEncoderlosslesslive
count · raw bytes10 · UTF-8
```
10 IDs
```
loaded · UTF-8MIME · ready
02
Inspect fingerprint
Each host gets a stable 8-char fingerprint that survives across runs.
Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.
hostWeb Cryptosubtledeterministiclive
fp · optionsa1b2c3d4 · live
```
fingerprint
```
options applied · livelive
03
Generate
Timestamp + counter + entropy + fingerprint, base36-encoded.
Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.
mintmemoisedoptionsinstantreactive
out · encodedcuid2 · ready
```
c0mxqw3v9kqz…
```
encoded · livelossless
04
Copy or download
Drop into a seed file or use as test fixtures.
Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.
exportclipboardblobMIME-correctclient-side
ok · copiedready · done
```
Copied
```
shipped · ready to shipsuccess

Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Use Cases

When to use CUID2

URLs, database keys, distributed systems.

Public URLs

Short enough for friendly URLs, opaque enough for safety. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

RFC-compliant

Database keys

Drop-in primary key for serverless databases. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

Idempotency

Stable client-generated IDs for retry-safe APIs. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

lossless

Distributed apps

Collision-resistant across multiple hosts. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

k-sortable storage

Roughly time-ordered for index locality. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Cross-system IDs

URL-safe and easy to embed in QR codes. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready

FAQ

Frequently asked questions

Why CUID2 over UUID?

CUID2 is shorter (24 chars vs 36), URL-safe by default, time-sortable, and friendly to humans. UUID v7 is similar but base-16 and longer.

Are CUID2s sortable?

Roughly. The leading timestamp portion gives k-sortable behaviour suitable for index locality, but exact ordering across hosts is not guaranteed.

How collision-resistant are they?

With 8 bytes of entropy plus a host fingerprint, collisions are astronomically rare at any practical scale.

Why the 'c' prefix?

It guarantees the ID starts with a letter, which keeps databases that treat columns as identifiers happy.

Is anything sent to a server?

No. CUID2 generation runs locally via Web Crypto.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!