ULID Generator - Generate Sortable Unique IDs Online
Generate ULIDs, extract timestamps, and convert between ULID and UUID formats. Monotonic generation for strict ordering — 100% client-side, no data sent to server.
Bulk Generation
Frequently Asked Questions
What is a ULID?
A ULID (Universally Unique Lexicographically Sortable Identifier) is a 128-bit identifier encoded as a 26-character string using Crockford's Base32. Unlike traditional UUIDs, ULIDs embed a 48-bit Unix timestamp (in milliseconds) in the first 10 characters, followed by 80 bits of cryptographic randomness in the remaining 16 characters. This design makes ULIDs lexicographically sortable by creation time while maintaining global uniqueness.
How do I use this ULID generator?
Use the Generate tab to create single or bulk ULIDs (up to 1000). Toggle Monotonic mode for strict ordering within the same millisecond. Use the Decode tab to paste any ULID and extract its embedded timestamp (ISO 8601, Unix milliseconds, and local time). Use the Convert tab to convert between ULID and UUID formats. Click Copy to copy any result to your clipboard.
Is my data safe? Does anything get sent to a server?
All operations are performed 100% in your browser using the Web Crypto API (crypto.getRandomValues()). No ULID data, timestamps, or UUIDs are ever transmitted to any server, stored in any database, or logged anywhere. You can verify this by disconnecting from the internet — the tool works fully offline.
What is the difference between ULID and UUID?
Both are 128-bit identifiers, but differ in key ways: ULID is 26 characters (Crockford's Base32), UUID is 36 characters (hexadecimal with hyphens). ULIDs are lexicographically sortable by creation time; UUIDs (v4) are randomly ordered. ULIDs contain no special characters and are URL-safe. ULIDs can be converted to/from UUIDs since both are 128-bit values.
What is monotonic ULID generation?
When multiple ULIDs are generated within the same millisecond, standard generation assigns random values each time, which can result in out-of-order ULIDs. Monotonic generation solves this by incrementing the randomness component by 1 for each ULID generated in the same millisecond, guaranteeing strict lexicographic ordering. This is critical for database systems that rely on ID ordering.
When should I use ULID instead of UUID?
Use ULID when you need time-sorted identifiers without a separate timestamp column, better database index performance (B-tree friendly), shorter string representation (26 vs 36 characters), or URL-safe identifiers. Use UUID when you need maximum ecosystem compatibility, RFC compliance, or built-in version/variant metadata.
Code Examples
// Crockford's Base32 alphabet
const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
// Generate a ULID
function generateULID() {
const timestamp = Date.now();
let ts = timestamp;
let timestampPart = '';
for (let i = 9; i >= 0; i--) {
timestampPart = ENCODING[ts % 32] + timestampPart;
ts = Math.floor(ts / 32);
}
const randomBytes = new Uint8Array(10);
crypto.getRandomValues(randomBytes);
const bits = Array.from(randomBytes)
.map(b => b.toString(2).padStart(8, '0')).join('');
let randomPart = '';
for (let i = 0; i < 16; i++) {
randomPart += ENCODING[parseInt(bits.slice(i*5, i*5+5), 2)];
}
return timestampPart + randomPart;
}
console.log(generateULID()); // "01ARZ3NDEKTSV4RRFFQ69G5FAV"