UUIDs and ULIDs are 128-bit identifiers represented as text. This tool generates random UUID v4 values, time-ordered UUID v7 values, or ULIDs in batches. It also decodes UUID and ULID text to expose the recognized type, variant, embedded time when available, and equivalent 128-bit representation.
Generation and decoding happen locally in the browser. Use the results for test data, database keys, request correlation, or format inspection, while choosing an identifier type according to the ordering and interoperability requirements of the system that will store it.
How to Use the UUID and ULID Generator
Choose an identifier format, generate a batch, or inspect an existing value.
- Choose UUID v4 (random), UUID v7 (time-ordered), or ULID from Type.
- Enter a Count from 1 through 1000.
- Select Uppercase if UUID output should use uppercase hexadecimal; ULID generation remains uppercase.
- Select Generate to replace the Identifiers list with a new batch.
- Select Copy all to copy the newline-separated Identifiers output.
- Paste a value into Decode a UUID or ULID to view Type, Variant when applicable, timestamp fields when available, As UUID, and As ULID.
Choosing Between UUID v4, UUID v7, and ULID
UUID v4 is primarily random. Its standard textual form contains 32 hexadecimal digits separated by hyphens, with version and variant bits reserved by the UUID format. It does not contain a creation timestamp, and the decoder states that explicitly. This tool generates v4 values with the browser's crypto.randomUUID() method.
UUID v7 places a Unix-epoch millisecond timestamp in the leading 48 bits and fills the remaining fields with version, variant, and random or monotonic data. That leading time component makes textual and binary ordering broadly follow creation time. The local generator increments a 12-bit sequence for values created in the same millisecond and prevents its timestamp from moving backward during the current page session.
ULID also combines a 48-bit millisecond timestamp with an 80-bit random portion and renders the result as 26 Crockford Base32 characters. This implementation generates uppercase ULIDs with browser cryptographic random bytes. Unlike its UUID v7 generator, its ULID generator does not add a same-millisecond monotonic sequence, so do not claim strict generation order for ULIDs created within one millisecond.
Choose based on the consuming system. UUID v4 is widely recognized and does not reveal creation time. UUID v7 provides standardized time ordering, while ULID offers a compact, case-insensitive Base32 representation. The separate UUID v7 generator is useful when you only need that format in bulk.
What the Decoder Reads from an Identifier
The decoder accepts a 26-character ULID or a UUID containing 32 hexadecimal digits. UUID input may include the usual hyphens, braces, or a urn:uuid: prefix. It recognizes Nil and Max UUID values, reads the version nibble, and classifies the variant as RFC 9562 or one of the reserved layouts.
For an RFC-variant UUID v1, v6, or v7, the decoder reconstructs the embedded time and shows Timestamp (UTC) plus Local time. A ULID also exposes its millisecond timestamp. Other UUID versions receive no timestamp row because their layouts do not provide one that this decoder reads.
As UUID and As ULID are alternate text encodings of the same 128 bits. They do not turn a random UUID v4 into a time-based ULID or change the UUID's version semantics. In particular, converting arbitrary UUID bits to ULID text can yield a Base32 value whose leading bits look like a timestamp even though the source UUID was never created as a ULID.
The decoder checks structure and bit fields, not provenance. It cannot prove that an identifier came from a conforming generator, is unique in a database, or belongs to a particular record.
Ordering, Collisions, and Timestamp Edge Cases
Time-ordered identifiers can improve locality in indexes compared with uniformly random leading bytes, but the effect depends on the database, index type, insertion rate, and storage representation. Benchmark the actual schema before making identifier format an architectural requirement.
Neither timestamps nor randomness create an absolute uniqueness guarantee. Collision risk is designed to be very small when generators use suitable randomness and implementations follow the format, yet applications should still enforce uniqueness where duplicates would be harmful. This page limits a generated batch to 1000 values, even if the Count field is empty, below 1, or above 1000; generation clamps the effective count into that range.
UUID v7 and ULID timestamps reveal approximate creation time. That can be helpful for sorting and debugging but undesirable when public identifiers should not disclose activity timing. Also remember that time ordering is based on generator clocks and algorithm details, not a global transaction order across devices.
The browser clock influences the embedded timestamp. UUID v7 generation compensates for a backward clock only within the lifetime of this loaded page; it does not coordinate across tabs, browsers, or servers. ULIDs generated in the same millisecond use fresh randomness rather than a monotonic counter.
Security and Privacy of Generated Identifiers
The tool uses browser cryptographic APIs for UUID v4, UUID v7 randomness, and ULID randomness, and it does not upload generated or decoded values. Even so, an identifier is usually a name, not a secret. Do not treat an unguessable-looking ID as authorization; protect records with authentication and access-control checks.
Time-based identifiers expose timing information, and copied production IDs may reveal internal references. Redact identifiers when they can be joined with logs, customer records, or private URLs. Generate fresh examples for documentation rather than publishing live values.
Avoid using these identifiers directly as encryption keys, passwords, or session tokens. Their layouts reserve predictable bits, and UUID v7 and ULID include predictable time fields. Use a purpose-built token generator and an appropriate security design when secrecy or authentication is the requirement.
Frequently Asked Questions
Does UUID v4 contain a timestamp?
No. UUID v4 is a random-based UUID with version and variant bits, so the decoder shows no timestamp and adds a note explaining that version 4 is random. A date inferred from its leading bytes would have no defined v4 meaning.
Are UUID v7 values sorted by creation time?
Their leading timestamp makes them time-ordered, and this page adds a sequence for same-millisecond generation in its current session. Ordering is not a universal event sequence across independent generators, however. Clock differences, separate tabs, and storage collation can affect the observed order.
Is a ULID the same thing as a UUID?
Both represent 128 bits, but their defined layouts and textual encodings differ. The decoder can display the same bits in either textual form, but that conversion does not make the source comply with the other format's generation semantics. Preserve the original type when its timestamp or ordering rules matter.
Why does the decoder show no timestamp for some UUIDs?
This implementation extracts dates only from RFC-variant UUID v1, v6, and v7 layouts, plus ULIDs. UUID v4 has no timestamp, and other versions or reserved variants are not decoded as time-bearing here. Missing timestamp output is therefore expected for many valid UUIDs.
Can I use generated IDs as access tokens?
That is a poor default. Identifiers are intended to distinguish records, while access tokens must meet a security protocol's entropy, lifecycle, storage, and validation requirements. Use authentication and authorization independently, even if a record ID is difficult to guess.
References: RFC 9562: Universally Unique IDentifiers · ULID specification.