A UUID (Universally Unique Identifier) is a 128-bit identifier standardised by RFC 9562 that can be generated independently across systems with a negligible probability of collision.

Which UUID version should I use for a database primary key?

Use UUID v7. It embeds a Unix millisecond timestamp in the leading bits, so it is monotonically increasing and dramatically improves B-tree index locality compared to UUID v4.

What is the difference between UUID v4 and UUID v7?

UUID v4 is fully random and unordered, ideal for opaque public IDs. UUID v7 is time-ordered: the first 48 bits are a Unix ms timestamp, so v7 values sort chronologically and index efficiently in databases.

ULID is a 128-bit identifier with a 48-bit timestamp and 80 bits of randomness, encoded in Crockford Base32 as a 26-character string. It is lexicographically sortable and URL-safe.

How many UUIDs can be generated before a collision?

For random UUID v4 you would need to generate roughly 2.71 quintillion (2.71 × 10^18) UUIDs to reach a 50% collision probability, making accidental collisions effectively impossible.

Yes. UUID Studio runs entirely in your browser, requires no signup and is 100% free.

UUID Generator & Analyzer

Generate, validate, decode, analyze, compare, and understand UUIDs instantly. Full support for v1, v3, v4, v5, v6, v7, v8 plus ULID, NanoID, KSUID, Snowflake and CUID2 — with a built-in database ID advisor, performance benchmarks and language-specific code (Java, Spring Boot, JPA, Kotlin, JS/TS, Python, Go, Rust, C#, PHP).

RFC 9562 compliant Crypto-secure 100% Free Runs in your browser

550e8400-e29b-41d4-a716-446655440000

Open Full Generator Validate a UUID Compare v4 / v7 / ULID

Quick definition. A UUID (Universally Unique Identifier) is a 128-bit value standardised by RFC 9562 that can be generated on any machine without coordination, with a collision probability so low it is treated as zero in practice. UUID v4 is fully random; UUID v7 prepends a Unix-millisecond timestamp so values sort chronologically and index efficiently in B-tree databases. For new systems, prefer UUID v7 as a primary key, UUID v4 for opaque public identifiers, and v3 / v5 when an ID must be deterministically derived from a name.

Bulk UUID Generator

Count

Version

Click Generate to produce a batch.

Preview first 200 lines

—

Validator, Decoder & Timestamp Extractor

UUID

Valid Version 7 Variant RFC 9562

Decoded fields

Bit layout

Format converter

UUID Comparator

UUID A

UUID B

—

Collision Probability

Number of IDs generated Identifier bit length

—

Entropy Analyzer

UUID

—

Distribution

Sample size

—

Performance Analyzer

Insert performance, index locality and storage cost for the most common 128-bit identifier choices. Lower latency and tighter indexes win.

Identifier	Size	Sortable	B-tree locality	Insert speed (relative)	Notes
UUID v4	128-bit	No	Poor (random)	1.0×	Index fragmentation under write load
UUID v7	128-bit	Yes (ms)	Excellent	2.8–4.2×	Drop-in replacement for v4 in PostgreSQL/MySQL
ULID	128-bit / 26 char	Yes (ms)	Excellent	2.6–3.8×	Crockford Base32, URL-safe
KSUID	160-bit / 27 char	Yes (s)	Excellent	2.5×	Larger, second-resolution timestamp
Snowflake	64-bit	Yes (ms)	Excellent	4.5×	Requires worker-id coordination
NanoID (21)	~126-bit / 21 char	No	Poor	1.1×	Smallest URL-safe random ID
CUID2	~24 char	No	Poor	0.9×	Designed to resist enumeration

Runs 100,000 generations of each format.

Format & Case Converter

Input UUID, hex, Base64 or binary

Batch Processor & Search

Paste a list of UUIDs one per line

—

Database ID Advisor

Database Workload

Pick a database and workload to get a recommendation.

Distributed ID Comparison

Feature	UUID v4	UUID v7	ULID	KSUID	Snowflake	NanoID	CUID2
Bits	128	128	128	160	64	~126	~144
String length	36	36	26	27	≤19	21	24
Time-ordered	No	Yes (ms)	Yes (ms)	Yes (s)	Yes (ms)	No	No
Sortable	No	Yes	Yes	Yes	Yes	No	No
URL-safe	Yes	Yes	Yes	Yes	Yes	Yes	Yes
Coordination	None	None	None	None	Worker-id	None	None
RFC / Spec	RFC 9562	RFC 9562	ulid/spec	segmentio	Twitter	ai/nanoid	paralleldrive/cuid2
Recommended for	Public opaque IDs	DB primary key	DB primary key	Event logs	Distributed services	Short URLs	Anti-enumeration

ULID, NanoID, KSUID, Snowflake, CUID2

NanoID length NanoID alphabet Snowflake worker / datacenter

Result

01JYABCD123XYZ...

Code for every stack

—

Saved History

Saved UUIDs appear here. Use the ★ Save button after generating.

UUID Internals — How It Works

Structure of a UUID

A UUID is 128 bits, conventionally formatted as xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx where M identifies the version (1–8) and the top bits of N identify the variant (RFC 9562 uses binary 10).

time_low · 32 bits time_mid · 16 bits version + time_hi · 16 bits variant + clock_seq · 16 bits node / random · 48 bits

UUID v1

60-bit 100-ns timestamp since 1582-10-15 + 14-bit clock sequence + 48-bit node ID (often MAC). Leaks host and time.

UUID v3

MD5 of (namespace UUID || name). Deterministic — same inputs always give the same UUID.

UUID v4

122 bits of cryptographic randomness. Fully unordered. The default opaque identifier.

UUID v5

SHA-1 of (namespace UUID || name). Same deterministic behaviour as v3 but stronger hash.

UUID v6

Reorders v1 so the timestamp is in big-endian order, making the UUID sortable.

UUID v7

48-bit Unix ms timestamp + 74 bits random. Time-ordered, RFC 9562 native, ideal for primary keys.

UUID v8

122 bits of user-defined data. Use when you need a custom layout that still claims a UUID slot.

Best practices

Use v7 for primary keys — chronological order avoids index page splits.
Use v4 for public IDs — no information leakage.
Store as native UUID / BINARY(16), never as VARCHAR(36).
Always use a cryptographically secure RNG (crypto.getRandomValues, SecureRandom).
Pair UUIDs with a monotonically increasing sequence only if you need strict ordering.

Common mistakes

Using UUID v1 in public APIs — it leaks the host MAC address.
Storing UUIDs as VARCHAR(36) instead of uuid / BINARY(16) — 2.25× the storage.
Picking UUID v4 as a clustered primary key — destroys B-tree locality.
Generating UUIDs with Math.random() — not cryptographically secure.
Exposing v1 / v6 / v7 IDs externally without considering the embedded timestamp.

Key takeaways

UUID v7 is the modern default for database primary keys (RFC 9562, 2024).
UUID v4 remains correct for opaque external identifiers.
ULID and v7 are functionally equivalent in ordering guarantees; choose ULID for shorter string form, v7 for native DB UUID type.
Snowflake wins on raw size (64-bit) but requires worker-id coordination.
NanoID and CUID2 are for URLs and anti-enumeration, not for high-throughput databases.
Collision probability for UUID v4 reaches 50% around 2.71 × 10¹⁸ generated IDs — effectively never in practice.

FAQ

Distributed ID Hub

Spring Boot Cron Expression Generator JSON Formatter Studio HTML Formatter & Code Quality Studio HTML Link Generator advanced free CSS toolkit Tailwind HTML to React JSX Converter All Developer Tools