UUID and ULID Generator
{{ summaryTitle }}
{{ summaryLine }}
ULIDs use canonical uppercase Base32 without dashes or braces. These UUID display settings are retained for your next UUID.
Generated {{ identifierKind }}
- {{ row.label }}
- {{ row.value }}
{{ computation.values.profile }} fit guide
Core mechanism
{{ computation.values.mechanism }}
Good fit
{{ computation.values.recommended_use }}
Handling note
{{ computation.values.privacy_note }}
The chart renderer is unavailable. Open this tab again to retry; exact bit counts remain available in the CSV export.
| # | Identifier | Type | Generated | Copy |
|---|---|---|---|---|
| {{ row.id }} | {{ row.formatted }} | {{ row.profile }} | {{ row.generatedAtDisplay }} |
Similar tools
- UUID Decoder Decode a UUID in your browser to check its version and variant, read timestamps from versions 1, 6 and 7 and copy its normalized text.
- SemVer Bump Required Checker Check release notes and commit subjects for the required SemVer bump, then verify whether a planned version covers the strongest change signal.
- Secure Password Generator Generate a unique password in your browser with adjustable character rules, unbiased random selection, and clear strength estimates.
- Test Credit Card Number Generator Generate Luhn-valid test credit card numbers with optional CVV and expiry for form testing, using a seed to reproduce the same dummy numbers.
Records created on different devices may need distinct identifiers before they reach the same database. UUIDs and ULIDs let those devices assign identifiers independently, which is useful when importing records, merging datasets or passing events between services. A database counter can still be sufficient within one database. Independent generation becomes useful when several places need to create IDs without coordinating each new number.
A universally unique identifier (UUID), also called a globally unique identifier (GUID), holds 128 bits. Its familiar text form contains 32 hexadecimal digits separated by four hyphens. A ULID, short for Universally Unique Lexicographically Sortable Identifier, also holds 128 bits, but uses 26 Base32 characters and always includes time. A ULID is a separate identifier format, so a field that accepts UUIDs does not automatically accept ULIDs.
The useful distinction is how an identifier relates to the record it labels. Three common needs lead to different choices.
- A new label for each record. Random UUID v4 uses fresh random data without encoding a name or creation time. It suits records whose identity should stay independent of their contents.
- The same label for the same name. UUID v3 and v5 combine a name with a namespace, another UUID that defines the naming context. Repeating the same version, namespace and name reproduces the identifier, which helps separate imports agree on the identity of a record.
- A label that carries time. UUID v7 and ULID put time first, allowing ordinary text sorting to group values chronologically. UUID v1 and v6 use an older time-and-node design, with v6 rearranging its timestamp to improve ordering.
Uniqueness always has a scope, such as one table, several services or a combined archive. A collision occurs when two records that should have different IDs receive the same value. Random generation makes that unlikely rather than impossible, and the risk grows with the number of values generated. Name-based generation deliberately repeats values for identical inputs. A receiving system should enforce the uniqueness its records require instead of treating an identifier's appearance as proof that it has never been used.
Changing letter case, removing UUID hyphens or adding braces changes the text representation, not the underlying identifier. A receiving application may nevertheless require one exact representation. Changing the UUID version or replacing a UUID with a ULID changes how the identifier is constructed and interpreted.
Time-based identifiers can help keep nearby records together in an ordered index, but they also reveal a timestamp. The timestamp reflects the generating clock, which may be wrong or move backward. Two IDs created within the same millisecond need not sort in creation order. For event records, a separate event-time field remains useful because the time an ID was generated may differ from the time the event occurred. None of these identifier formats supplies authentication or permission to access a record.
How to Use This Tool:
With default settings, the page generates one UUID v4 automatically. Start with the format required by the system that will receive the identifier.
- Choose an Identifier type. Keep v4 for a random UUID, choose v5 for repeatable name mapping, or select v7 or ULID when a visible timestamp is useful. Versions 1, 3 and 6 support systems that require those particular UUID mechanisms.
- Enter Name and Namespace for v3 or v5. The initial examples are
example.comandDNS. A name must remain nonempty after trimming and fit the 512-character limit. Namespace aliasesDNS,URL,OIDandX500are case-insensitive. For a custom namespace, a canonical, dashed UUID v4 is a practical choice.A namespace such asproject-alphais not a UUID. If the warning prevents generation, enter a standard alias or a valid canonical namespace UUID. Braces, a UUID URN and dashless UUID text are not accepted in this field. - Click Generate UUID or Generate ULID. Changing the type, name or namespace clears the previous current result. Wait until the summary says the generated identifier is ready before copying it. Each click produces one identifier; there is no batch-size control.
- Open Advanced if the receiving system needs UUID text in a different form. Uppercase output, Remove dashes and Wrap in braces can be combined, and all start off. Changing them reformats the current UUID without generating another one. Turning them off restores its lowercase, dashed display. In ULID mode these controls are disabled, while their settings remain available when you switch back to a UUID type and generate again.
- Copy the intended value with Copy UUID or Copy ULID. UUID copying uses the current formatting choices; ULID copying uses the canonical 26-character value. Confirm that the destination accepts that representation. If browser copying fails, select and copy the displayed text manually.
Interpreting Results:
Identifier review describes the identifier just generated. It is not a decoder for pasted values. For UUIDs, Canonical UUID stays lowercase and dashed, and URN adds urn:uuid: to that canonical value. These remain unchanged when display formatting changes. ULIDs have their own canonical value, time prefix and random tail, with no UUID URN.
Generated at records the generation event in the browser's local time. It does not mean that time is encoded in every UUID. In particular, v3 and v5 can be generated again later with identical values. The additional v7 embedded-time reading and the ULID UTC reading come from their timestamp content. Neither is a trusted clock measurement or proof of when a record was created elsewhere.
Format fit explains the selected type's intended use and handling limits. Bit allocation compares its field sizes with UUID v4, UUID v7 and ULID, without repeating a type already in the comparison. The bars show how many bits each field occupies, not their exact positions in the encoded value. The comparison can be saved as an image or as CSV containing the exact bit counts.
The Generation ledger keeps the latest 20 successful generation events, newest first. Rows retain the formatting used when they were created, so later formatting changes do not rewrite earlier entries. Repeated v3 or v5 values can legitimately appear in several rows. Copy individual rows or CSV, or download the ledger as CSV or DOCX before leaving if you need a record. Reloading or closing the page discards the ledger; it is not a registry of every identifier ever generated.
Technical Details:
UUID structure and version rules
A UUID contains 16 bytes. In the UUID versions generated here, four bits identify the version and two identify the RFC variant, leaving 122 bits for time, names, randomness or other fields. The version identifies the construction method; the variant identifies the broader layout convention.
The canonical pattern is xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx. The first digit of the third group, M, is the version number. The first digit of the fourth group, N, is 8, 9, a or b, whose leading bits are the RFC variant's binary 10. Hyphens add no bits.
These allocations explain why equal-length identifiers can reveal different information. Add four version bits and two variant bits to each UUID row to reach 128 bits. ULID uses all 128 bits for time and randomness, with no UUID markers.
| Identifier | Data fields | Construction |
|---|---|---|
| UUID v1 | 60 timestamp bits, 14 clock-sequence bits, 48 node bits | Gregorian time with the lower timestamp fields first. |
| UUID v3 | 122 hash-derived bits | MD5 of namespace bytes followed by name bytes. |
| UUID v4 | 122 random bits | Cryptographic random bytes with UUID markers set. |
| UUID v5 | 122 hash-derived bits | The leading 128 bits of SHA-1, with UUID markers set. |
| UUID v6 | 60 timestamp bits, 14 clock-sequence bits, 48 node bits | The v1 timestamp reordered from most to least significant. |
| UUID v7 | 48 timestamp bits, 74 random bits | Unix milliseconds first, followed by random payload and UUID markers. |
| ULID | 48 timestamp bits, 80 random bits | Unix milliseconds followed by randomness, with no UUID markers. |
Standard UUID text has 36 characters. Removing its hyphens leaves 32, and braces add two characters to either form. Uppercase changes neither the length nor the bits. ULID's 26-character representation is shorter because Base32 carries more bits per character than hexadecimal, not because the underlying identifier is smaller.
Name-based UUIDs and namespaces
A namespace separates one naming context from another. The same text can label different things in DNS, a URL collection or a private record system. UUID v3 and v5 hash the namespace's 16 binary bytes, in network byte order (most significant byte first), followed by the UTF-8 bytes of the name. They do not hash the printed namespace text or the alias itself.
The four standard aliases resolve to these fixed namespace UUIDs.
| Alias | Naming context | Namespace UUID |
|---|---|---|
DNS | Domain Name System names | 6ba7b810-9dad-11d1-80b4-00c04fd430c8 |
URL | Uniform Resource Locators | 6ba7b811-9dad-11d1-80b4-00c04fd430c8 |
OID | Object identifiers | 6ba7b812-9dad-11d1-80b4-00c04fd430c8 |
X500 | X.500 distinguished names | 6ba7b814-9dad-11d1-80b4-00c04fd430c8 |
MD5 produces 128 bits for v3. SHA-1 produces 160 bits for v5, of which the leading 128 are kept. Replacing the version and variant bits leaves 122 bits derived from the hash. This is a field-size statement, not a claim of 122-bit cryptographic security.
For a repeatable v5 example, the DNS namespace and example.com produce this sequence.
- Join the 16 namespace bytes represented by
6ba7b8109dad11d180b400c04fd430c8with the UTF-8 bytes ofexample.com. - Compute SHA-1, giving
cfbff0d193753685568c48ce8b15ae17d93cc34c. - Keep the first 16 bytes, represented by
cfbff0d193753685568c48ce8b15ae17, and replace the version and variant bits. - Format the result as
cfbff0d1-9375-5685-968c-48ce8b15ae17.
With the same namespace and name, v3 instead produces 9073926b-929f-31c2-abc9-fad77ae3e8eb. Repeating either calculation reproduces its value. Changing only UUID display options leaves that calculation unchanged.
Names are trimmed at both ends before hashing here. Case, internal whitespace and Unicode representation otherwise remain significant. Choosing DNS does not lowercase the name, look it up or verify ownership, so Example.com and example.com produce different values. Agree on name normalization before using deterministic IDs across systems. The name limit is 512 UTF-16 code units, so a supplementary Unicode character uses two units.
Time in UUID v1, v6 and v7
UUID v1 and v6 count 100-nanosecond intervals since 15 October 1582 at 00:00 UTC. Version 1 stores the timestamp's lower portions first. Version 6 places its more significant timestamp bits first while retaining the clock sequence and node field. This improves chronological ordering of the canonical representation without removing the information those fields carry.
The browser clock supplies milliseconds. A counter distinguishes repeated v1 generations within a millisecond, so the timestamp's 100-nanosecond units do not imply 100-nanosecond clock accuracy. The 14-bit clock sequence starts randomly and changes when the clock moves backward. The node field is randomly selected for the loaded page, with its multicast flag set, and reused by subsequent v1 and v6 generations. It is not read from the device's hardware MAC address.
UUID v7 uses milliseconds since 1 January 1970 at 00:00 UTC instead. Its leading 48 bits hold that timestamp. The v7 values generated here fill the remaining 74 payload bits with fresh cryptographic randomness. There is no counter that forces successive values within the same millisecond to increase.
ULID encoding and bounds
A ULID places a 48-bit Unix-millisecond timestamp before 80 random bits. In binary, these are six timestamp bytes followed by ten random bytes, with the most significant byte first. The complete integer can be expressed as follows.
Here, U is the 128-bit ULID value, T is the whole-number timestamp in milliseconds, and R is the unsigned 80-bit random value. T ranges from 0 through 281,474,976,710,655 inclusive. R ranges from 0 through two to the power of 80 minus one. Negative, fractional or overflowing timestamps cannot form a valid ULID and are rejected rather than rounded or truncated.
The integer is encoded with 0123456789ABCDEFGHJKMNPQRSTVWXYZ. This Crockford Base32 alphabet excludes I, L, O and U. Canonical output is uppercase, with ten characters for time and sixteen for randomness. ULIDs do not add hyphens, braces or a checksum character.
Twenty-six Base32 characters have room for 130 bits. A ULID uses only 128, so the two leading padding bits must be zero and its first character must be 0 through 7. Later characters may use the full alphabet. The largest valid value is 7ZZZZZZZZZZZZZZZZZZZZZZZZZ; a value starting with 8 already exceeds the 128-bit range.
These fixed examples make the encoding boundaries visible. They are explanatory values, not selectable generation inputs: ordinary generation uses the current browser clock and fresh randomness.
| Unix milliseconds | 80-bit random value in hexadecimal | Canonical ULID |
|---|---|---|
| 0 | 00000000000000000000 | 00000000000000000000000000 |
| 1 | 00000000000000000001 | 00000000010000000000000001 |
| 1469922850259 | d6764c61efb99302bd5b | 01ARZ3NDEKTSV4RRFFQ69G5FAV |
| 281474976710655 | ffffffffffffffffffff | 7ZZZZZZZZZZZZZZZZZZZZZZZZZ |
The example 01ARZ3NDEKTSV4RRFFQ69G5FAV has the time prefix 01ARZ3NDEK and random tail TSV4RRFFQ69G5FAV. Its timestamp is 30 July 2016 at 23:54:10.259 UTC. Knowing that timestamp is enough to read the date, but not to predict the independently generated random tail.
Ordering and collision probability
For canonical ULIDs compared in ASCII character order, an increasing timestamp sorts after every value from an earlier millisecond. Canonical UUID v7 values have the same timestamp-first property. Within one millisecond, their fresh random portions determine the order. This generator does not use a monotonic ULID sequence, which would deliberately increase successive values. A backward clock adjustment can produce an identifier that sorts before an earlier generation, and clocks on different devices need not agree. Sorting different identifier types together does not establish a shared chronology.
Randomness also defines the chance of accidental duplicates. For independent, uniformly distributed choices and a small collision probability, the birthday approximation is:
Here, p is the probability of at least one collision among n generated values, and b is the number of independently random bits. For UUID v4, b is 122 and n counts the whole collection. For the v7 and ULID choices here, b is 74 and 80 respectively, and n counts values sharing one timestamp, including any return to that timestamp after a clock adjustment. Values with different timestamp fields cannot be identical.
For example, one billion independent UUID v4 values give an approximate collision probability of 9.4 × 10−20. This estimate assumes a sound random source and independent draws. It does not prove that a particular collection has no duplicates, and it does not apply to deliberately repeated name-based UUIDs.
Privacy Notes:
Identifier generation runs in your browser. The tool does not upload generated values to a generation service or keep them in persistent browser storage. Loading the page and some optional generation or chart resources can still require network access.
- A settings URL can contain the selected type, name, namespace and UUID formatting choices. Generated identifiers, random data, generation times and ledger entries are not added to it. Names and namespaces can still disclose information through a shared or bookmarked URL, and anyone who knows a v3 or v5 name and namespace can reproduce its identifier.
- Reloading a settings URL restores the choices and generates again. Random and time-based values are newly generated; the same v3 or v5 inputs reproduce the same identifier. An unsupported identifier type must be corrected before generation.
- UUIDs and ULIDs are record labels, not passwords, API keys or bearer tokens. MD5 and SHA-1 name mapping does not provide password protection or prove content authenticity. Keep authentication and access checks separate from the identifier, and account for the visible time or repeated node information before publishing time-based values.
FAQ:
Why does a custom namespace report Invalid UUID?
A namespace can have the right dashed shape but still be rejected during generation. Custom namespaces currently accept UUID versions 1 through 5 with the RFC variant, or the all-zero UUID. UUID v6 and v7 cannot serve as namespaces here even though they can be generated. Use a standard namespace alias or a canonical UUID v4, then generate again.
What if generation is unavailable or fails to finish?
All choices require browser Web Crypto, including v3 and v5. If it is unavailable, use a browser where that capability is available; there is no fallback to weaker randomness. Versions 1, 3, 5 and 6 also need additional generation resources to load. Restore access to those resources and click Generate again if loading fails. Failure leaves no current value to copy. If you change the type, name or namespace while loading, the result for the old settings is discarded; wait for loading to finish and generate with the current choices.
What if the bit-allocation chart is unavailable?
Open the Bit allocation tab again to retry. The exact bit counts remain available through its CSV download even when the chart cannot render. PNG, WebP and JPEG downloads become available when the chart is ready.
References:
- RFC 9562: Universally Unique IDentifiers (UUIDs), Internet Engineering Task Force, May 2024.
- ULID specification, ULID project.
- Base 32, Douglas Crockford, March 2019.
- Web Cryptography Level 2: Cryptographic random values, World Wide Web Consortium, working draft, April 2025.
- How to change a disk or partition filesystem UUID in Linux, Simplified Guide.