Enter one or more ULIDs, one per line
Ready to validate
Paste a ULID and click Validate// verify ulid structure and extract embedded timestamp
Validate ULID structure, verify format compliance, and extract the embedded timestamp from any ULID string instantly in your browser.
Ready to validate
Paste a ULID and click ValidateEnter one or more ULID strings in the input box, one per line.
The tool checks structure, character set, length, and timestamp range instantly.
Each ULID shows validity status plus the decoded UTC timestamp embedded in its first 10 characters.
A ULID (Universally Unique Lexicographically Sortable Identifier) is a 128-bit identifier encoded as a 26-character Crockford Base32 string. The first 10 characters encode a 48-bit millisecond-precision Unix timestamp, and the remaining 16 characters are 80 bits of randomness. This tool validates the structure and decodes the timestamp portion.
ULIDs use Crockford's Base32 encoding: the digits 0–9 and uppercase letters A–Z, excluding I, L, O, and U to avoid visual ambiguity. Valid characters are: 0123456789ABCDEFGHJKMNPQRSTVWXYZ.
A ULID is always exactly 26 characters long. The first 10 characters encode the timestamp, and the remaining 16 characters are random. Any ULID that is shorter or longer is invalid.
Officially, ULIDs are uppercase. However, many implementations accept lowercase input and normalize it. This validator checks both and will flag mixed-case or lowercase as a warning while still decoding the timestamp.
The 48-bit timestamp component can encode times from the Unix epoch (January 1, 1970) up to the year 10889. In practice, any ULID with a timestamp far in the future may indicate a generation error or test data.
Unlike UUIDs, ULIDs are lexicographically sortable — a list of ULIDs, when sorted alphabetically, is also sorted by creation time. They are also more compact (26 chars vs 36 for a UUID with hyphens) and URL-safe without encoding.
This validator checks against the original ULID specification. Non-standard variants (such as seeded or monotonic implementations that modify the random portion) will still pass validation if the format and character set are correct.
A ULID — Universally Unique Lexicographically Sortable Identifier — is a modern alternative to UUID designed for distributed systems that need both uniqueness and meaningful sort order. Introduced by Alizain Feerasta, the ULID specification defines a 128-bit identifier encoded as a 26-character Crockford Base32 string. The key innovation is that the first 48 bits encode a millisecond-precision Unix timestamp, meaning that ULIDs generated in chronological order are also in alphabetical order when sorted as strings.
💡 Looking for premium web development assets? MonsterONE offers unlimited downloads of templates, UI kits, and developer assets — worth checking out.
Every ULID is exactly 26 characters, split into two logical parts. The timestamp component occupies the first 10 characters and encodes 48 bits representing milliseconds elapsed since the Unix epoch (January 1, 1970, 00:00:00 UTC). This gives a range from the epoch all the way to the year 10889, far exceeding any practical requirement. The randomness component fills the remaining 16 characters with 80 bits of cryptographically random data, providing collision resistance even when multiple ULIDs are generated within the same millisecond.
The character set used is Crockford's Base32: the ten digits (0–9) plus 22 uppercase letters (A–Z), deliberately excluding I, L, O, and U to prevent confusion with the digits 1, 1, 0, and the letter V in various fonts. This results in exactly 32 symbols, making the encoding both compact and visually unambiguous — important when ULIDs appear in logs, URLs, or printed documents.
In production systems, data integrity problems often trace back to malformed identifiers. ULID validation catches several categories of errors early:
Decoding the timestamp portion of a ULID is a straightforward Base32 decoding step. Take the first 10 characters of the ULID and decode them using Crockford's alphabet, treating the result as a big-endian 48-bit integer. That integer is the number of milliseconds since the Unix epoch. Convert it to a Date object in JavaScript using new Date(timestampMs), or to a datetime in Python using datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc).
For example, the ULID 01ARZ3NDEKTSV4RRFFQ69G5FAV starts with 01ARZ3NDEK. Decoding this segment yields a timestamp of approximately 1469918176385 milliseconds, which corresponds to 2016-07-30T22:36:16.385Z — the moment that ULID was generated.
Both ULIDs and UUIDs solve the distributed uniqueness problem, but they have different trade-offs. UUID v4 is entirely random — it provides no information about when or where it was created, and a list of random UUIDs in any sort order is just as arbitrary as any other order. This makes UUID v4 ideal when you explicitly want no correlation between identifiers and insertion time.
ULIDs shine when sort order matters. Because the timestamp is encoded in the most-significant bits, a B-tree index on a ULID column in PostgreSQL, MySQL, or similar databases will naturally cluster recently inserted rows together on the same index pages, dramatically reducing write amplification compared to random UUIDs. This is the same benefit that UUID v7 (draft RFC) aims to bring to the UUID ecosystem, and ULIDs have been solving this problem since 2016.
Standard ULID generation is not strictly monotonic within a single millisecond — two ULIDs generated at the same timestamp could theoretically sort in either order due to randomness. To guarantee strict ordering, some libraries implement a monotonic ULID mode: when a new ULID is generated within the same millisecond as the previous one, the random component is incremented by one rather than freshly randomized. This guarantees that every ULID is strictly greater than the previous, at the cost of a small risk of random component overflow (which is handled gracefully by incrementing into the timestamp field).
Our validator checks the format and timestamp but does not assess monotonicity, since that property is only meaningful when examining a sequence of ULIDs in context.
ULID libraries are available for virtually every major language. In JavaScript/TypeScript, the ulid package on npm is the de facto standard and provides both standard and monotonic generation. Python developers typically use the python-ulid package or ulid-py. Go has github.com/oklog/ulid, the original reference implementation. Java and Kotlin can use com.github.f4b6a3:ulid-creator. Rust developers have the ulid crate on crates.io. In all cases, this validator can be used to verify that the output of any library conforms to the specification.