⌘ K
ulid · sortable · 26 chars · local

Generate ULIDs — time-sortable IDs

Universally Unique Lexicographically Sortable IDs. 48 bits timestamp + 80 bits randomness → 26 Base32 characters. Runs entirely in your browser.

ULID Generator
Count
0
5 requested
Length
26
Crockford Base32
Output
0 B
idle
Status
loading
sortable
Count:
input · controls
Custom count

ULID = 48 bits millisecond Unix time + 80 bits randomness. Lexicographically sortable, 26 Crockford Base32 characters.

For time-ordered database keys, ULID and UUID v7 are interchangeable choices.

output · ulid (0)

Click Generate to mint ULIDs

Quick Start

How to generate ULIDs

A ULID encodes a millisecond-precision Unix timestamp in the first 48 bits and 80 bits of randomness in the rest. They sort like UUID v7 but use a human-readable Crockford Base32 alphabet.

  1. 01

    Pick a count

    1 to 500 per click.

    Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.

    countUTF-8TextEncoderlosslesslive
    count · raw bytes5 · UTF-8
    5 ULIDs
    loaded · UTF-8MIME · ready
  2. 02

    Generate

    Each call mints fresh ULIDs with the current timestamp.

    Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.

    bulkWeb Cryptosubtledeterministiclive
    out · optionsULID · live
    01HXAB12CDE3F4G5H6JKMNPQRS
    options applied · livelive
  3. 03

    Sort-friendly

    ULIDs minted in the same millisecond sort monotonically — great for DB primary keys.

    Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.

    sortablememoisedoptionsinstantreactive
    order · encodedasc · ready
    time → random
    encoded · livelossless
  4. 04

    Copy or download

    Copy all or download as .txt.

    Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.

    exportclipboardblobMIME-correctclient-side
    ok · copiedready · done
    Copied
    shipped · ready to shipsuccess
Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Related toolsUUID v7UUIDNano IDSnowflake IDAPI KeyHashids
Use Cases

When to use ULID

Time-sortable primary keys, log correlation, event IDs.

Database primary keys

Avoid B-tree index fragmentation from random UUIDs. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

RFC-compliant

Event IDs

Event streams sort by ID without an extra timestamp column. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

Log correlation

Trace requests through systems with sortable IDs. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

lossless

File names

Drop-in for uploaded blobs — sortable by upload time. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

Audit trails

Lexically sortable IDs simplify chronological replay. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Distributed counters

Generate IDs on any node, sort globally by time. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready
FAQ

Frequently asked questions

A 128-bit identifier: 48 bits ms timestamp + 80 bits random, encoded as 26 Crockford Base32 chars. Lexicographically sortable.
Same idea — both encode time then random. ULID uses Crockford Base32 (26 chars), UUID v7 uses hex with hyphens (36 chars).
Crockford Base32 removes ambiguous characters so people can read IDs aloud without confusion.
80 random bits per millisecond — billions per ms before meaningful collision risk.
No. ULIDs are generated locally using the ulid library — IDs never leave your browser, all runs locally.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!