UUID Generator

A UUID generator is a tool that creates universally unique identifiers, 128-bit values used to label data without a central registry. Each identifier is built so the odds of two systems producing the same value are close to zero. Developers rely on one whenever an ID needs to be unique across multiple servers, databases, or applications running independently.

Unlike sequential IDs, a UUID does not depend on a database counter or coordination between services. This makes UUID generation ideal for microservices, offline-first apps, and any system where multiple nodes create records at the same time. UUIDs are standardized under RFC 4122, so tools and libraries across different programming languages produce compatible values.

Generating a UUID with this UUID generator takes a few clicks, and the entire process runs in your browser. Pick a version from the selector: v1, v3, v4, v5, v7, Nil, or ULID. Enter how many you need, from 1 up to 1,000 per batch. Click Generate and your identifiers appear instantly, ready to copy.

Formatting options apply to every version: toggle uppercase or lowercase, hyphens on or off, and braces if your system expects them. Copy a single result, copy the full batch, or download it as a `.txt`, `.json`, or `.csv` file. No sign-up, installation, or configuration is required before you start.

Generating Namespace-Based UUIDs (v3 and v5)

Versions 3 and 5 need a namespace and a name instead of pure randomness, since they are built to be deterministic. Pick a standard RFC 4122 namespace preset, DNS, URL, OID, or X.500, or supply your own custom namespace UUID. Enter a name, and the tool hashes the two together with MD5 for v3 or SHA-1 for v5. The same namespace and name will always produce the same UUID, and that's the point. Independent systems can generate matching identifiers for the same input without ever coordinating directly.

Decoding an Existing UUID or ULID

Paste any UUID or ULID into this UUID generator's decode panel to inspect it without generating a new one. The tool identifies its version and variant instantly. For v1, v7, and ULID values, it also decodes the embedded timestamp into a readable date and time.

This is useful for checking when a record was created, or for verifying a third-party API returned a valid identifier. It also helps confirm which version an unfamiliar UUID actually is.

UUID stands for Universally Unique Identifier, and the specification defines several versions, each built with a different method. The version number is embedded in the identifier itself, so any UUID reveals how it was generated. This generator supports every major version, with v4 set as the default for general-purpose use.

Unlike sequential IDs, a UUID does not depend on a database counter or coordination between services. This makes UUID generation ideal for microservices, offline-first apps, and any system where multiple nodes create records at the same time. UUIDs are standardized under RFC 4122, so tools and libraries across different programming languages produce compatible values.

Version 1 UUIDs combine a timestamp with the generating device's MAC address. This method can leak hardware information, so it sees less use today. Version 4 UUIDs use random or pseudo-random numbers instead, avoiding that trade-off entirely. Version 5 UUIDs generate a deterministic value from a namespace and a name using SHA-1 hashing, similar to output from the <hashLink>Hash Generator</hashLink>.

Version 4 UUIDs contain 122 random bits, since a handful of bits are fixed to mark the version and variant. That leaves an enormous number of possible combinations, roughly 5.3 undecillion. The odds of two randomly generated UUIDs colliding are so small that they are treated as effectively zero in practice.

No central authority tracks which UUIDs have already been issued. None is needed for the math to hold up. Even generating a billion UUIDs every second for a hundred years would use only a tiny fraction of the possible values. Deterministic versions like v3 and v5 work differently, since the same namespace and name are designed to repeat on purpose.

Within a single batch, v1, v4, and v7 values are checked against each other automatically. Duplicates are regenerated before the results are shown, so you won't see an accidental repeat. Version 3 and 5 batches skip that step by design, since the same namespace and name are meant to repeat. A batch of Nil UUIDs repeats too, since Nil UUID has only one possible value: all zeros.

ULID batches use a different safeguard. Each value combines a millisecond timestamp with a monotonic random component. That keeps collisions unlikely even within the same batch.

This kind of tool is essential wherever independent systems need to create IDs without checking in with each other first. Database primary keys are a common use case, especially in distributed or sharded databases. Sortable versions like v7 and ULID fit databases that also need chronological ordering, since standard random UUIDs cannot provide that.

API session tokens and authentication codes also rely on UUIDs for their unpredictability, similar to the random strings from the <passwordLink>Password Generator</passwordLink>.

Microservices use UUIDs to tag events, messages, and transactions so they can be traced across independent services. Authentication tokens like JWTs often use a UUID as the jti claim, and the <jwtLink>JWT Decoder & Encoder</jwtLink> can inspect that claim directly. File systems and object storage use UUIDs to name uploads without risking a naming collision. Test suites use this tool to create realistic, non-repeating mock data for QA environments.

UUID and GUID refer to the same underlying concept, a 128-bit identifier designed to be unique without central coordination. GUID stands for Globally Unique Identifier and is the term Microsoft uses across Windows, .NET, and SQL Server. UUID is the term used in the official RFC 4122 specification and across most other platforms.

In practice, the two formats are interchangeable and follow the same structure. A GUID generated on a Windows system will validate as a UUID anywhere else. The only real difference is naming convention, not the underlying algorithm or data structure.

A UUID is displayed as 32 hexadecimal characters arranged in five groups, separated by hyphens. The pattern follows an 8-4-4-4-12 structure, for example 550e8400-e29b-41d4-a716-446655440000. Two of those characters are reserved to encode the UUID's version and variant.

The version digit sits at the start of the third group. A UUID starting with a 4 there is a version 4 UUID. The variant bits sit at the start of the fourth group, confirming the identifier follows the RFC 4122 layout. A ULID looks different: it's 26 characters of Crockford Base32, with no hyphens and no version digit to read.

Every UUID produced by this generator is created directly in your browser using a cryptographically secure random number source. No UUID, and no data related to your session, is ever transmitted to a server. This makes the tool safe to use for internal, sensitive, or production-adjacent identifiers.

Because generation happens client-side, refreshing or closing the page leaves no record of what was created. There is no account, tracking, or storage tied to your generated UUIDs. You can generate additional batches as often as you need, right in the same browser tab.

For workflows that also need message integrity, the <hmacLink>HMAC Generator</hmacLink> offers a complementary way to verify data hasn't been tampered with.

The following examples show how the same generator output gets applied across different real-world scenarios. Each one starts with a UUID produced by this tool and shows where it fits in an actual system. Reviewing a few concrete cases makes it easier to see how a UUID behaves once it leaves the generator.

Each scenario above uses the exact same output format, so no conversion or reformatting is needed between use cases. Whether the identifier ends up in a database column, a URL, or a filename, it works without modification.

This consistency is why teams standardize on UUIDs across a stack, often alongside tools like the <base64Link>Base64 Encoder</base64Link>.