UUID Generator

A UUID is a 128-bit identifier designed to be unique without any central coordination. That is the whole value proposition, and the reason a UUID generator is a permanent fixture in every developer's bookmark bar: two systems, in two data centres, with no communication between them, can each mint identifiers and be confident they will never clash. When you need one — or a thousand — this UUID generator produces v4, v7, v1 and NIL values locally, using the browser's cryptographic random source, with nothing transmitted and nothing to install.

The identifier is 32 hexadecimal digits rendered in five groups, and the version digit in the third group tells you which minting strategy produced it. Most of the time that distinction is academic — you paste a UUID somewhere and move on — but choosing the right version up front saves real pain in database indexes, API design and privacy audits later.

The anatomy of a UUID

A UUID renders as 32 hexadecimal digits in five groups: 8-4-4-4-12.

f47ac10b-58cc-4372-a567-0e02b2c3d479
              ↑    ↑
           version variant

The first digit of the third group is the version. The first digit of the fourth group is the variant, which for all modern UUIDs is 8, 9, a or b — indicating the RFC 4122 layout.

UUID versions worth knowing

v1 — timestamp and node. Combines a 60-bit timestamp with the generating machine's MAC address. Ordered and traceable, but it leaks the creation time and, historically, hardware identity. Still used in legacy COM and Windows systems.

v3 and v5 — name-based hashes. Deterministic: the same namespace plus the same name always yields the same UUID. v3 uses MD5, v5 uses SHA-1; prefer v5. Useful for generating stable identifiers from URLs, email addresses or domain names.

v4 — random. 122 random bits. The default choice, supported natively by crypto.randomUUID() in every modern browser.

v6 — reordered v1. The same fields as v1 but arranged so the timestamp sorts first. A compatibility option for systems migrating off v1.

v7 — Unix time plus random. A 48-bit millisecond timestamp followed by 74 random bits. Sortable, index-friendly and privacy-safe, because the timestamp carries no hardware identity. This is the version new systems should choose for primary keys.

NIL. 00000000-0000-0000-0000-000000000000 — the sentinel value meaning "no identifier". Useful as a default and for testing null handling.

Choosing between UUID v4 and UUID v7

Use v4 when identifiers are exposed to users or clients and you do not want them to reveal anything about creation order or rate. An API key, a session ID, a file name in a public bucket — all better as v4, because v7 lets an observer infer when things were created and how fast.

Use v7 for internal database primary keys. The sequential prefix turns random-insert index churn into append-only writes. On a large PostgreSQL or MySQL table the difference in index size and write latency is substantial and well documented.

Formatting generated UUIDs for real use

• Plain hex (32 characters) for fixed-width storage and some legacy systems.
• Braces for .NET, SQL Server's uniqueidentifier literals and Windows GUID conventions.
• Uppercase where a system's collation or display convention requires it — UUID comparison is case-insensitive at the byte level.
• Quoted list for WHERE id IN (...) clauses and JSON arrays of test fixtures.

Store them as a native UUID type or as BINARY(16) where the database supports it. Storing 36-character strings in a VARCHAR column wastes space and slows every index that touches them.

Why generate UUIDs instead of auto-increment IDs

An auto-incrementing integer is simpler, smaller and faster — until two environments need to merge, an offline client needs to create records, or the sequence becomes an information leak revealing order volumes and user counts. A UUID removes the coordination: any node can generate a globally unique ID at any time, without a round trip, without a lock, without revealing how many rows came before. The trade is storage width and index locality, and UUID v7 exists precisely to buy back the second half of that trade.

Generating UUIDs in bulk

Seed data, test fixtures, migration keys and load-test corpora all want identifiers by the hundred, not the one. The bulk mode of this UUID generator emits up to a thousand values in one pass, in the output format your consumer expects: hyphenated for display and logs, plain hex for fixed-width columns, uppercase or brace-wrapped for .NET and SQL Server, or a quoted comma-separated list ready to paste into a SQL IN clause or a JSON array. Because generation is client-side, a thousand production-shaped identifiers cost one click and zero network traffic.

A free UUID generator with no strings attached

No account, no rate limit, no logging of generated values. Identifiers minted in your tab never touch a server, which is the right default for anything pre-launch: keys for an unreleased system, tokens for a private integration, IDs for data that is not public yet. Generate, copy, close the tab — nothing persists anywhere except your clipboard.