FIRST CH TOOLS / Dev / 26 UUID & ULID GENERATOR
UUID (v4, v7) & ULID Bulk Generator
Generate UUID v4, v7 and ULID values 1 to 100 at a time and copy them straight away. The randomness comes from your browser's cryptographic RNG, and the values are never sent anywhere.
What it does, in detail
Mint fully random UUID v4, time-ordered UUID v7 (RFC 9562) or ULID values for test data and migrations. Write them out as a JSON array, comma separated, quoted for SQL, upper case, without hyphens or in braces (GUID), and recall common combinations with one use-case button. The settings can be saved or shared as a URL (the generated values are never part of it). v7 and ULID stay monotonic within a millisecond, so a batch sorts as text in creation order. The comparison below shows the length, time part and sort order of all three and saves it as an image.
Format: one per line · lower
Press Generate and the IDs appear here.
Only type, count and format go in. Each visit generates new IDs.
| Part | Value | What it is |
|---|
UUID v4 vs v7 vs ULID
| UUID v4 | UUID v7 | ULID | |
|---|---|---|---|
| Length (canonical text) | 36 | 36 | 26 |
| Time part | none | first 48 bits (ms) | first 48 bits (ms) |
| The rest | 122 random bits | 74 bits (random / counter) | 80 random bits |
| Sorted as text | unrelated to creation | creation order | creation order |
| Creation time from the ID | not readable | readable | readable |
| Defined in | RFC 9562 §5.4 | RFC 9562 §5.7 | ULID spec (not an RFC) |
v7 and ULID sort in creation order across milliseconds thanks to the time part, but within one millisecond only if the generator keeps them monotonic. This tool does so for both (v7 per RFC 9562 §6.2 Method 2, ULID per the monotonic rule of the ULID spec).
Share the sort-order difference as an image
Five of each type made in the same millisecond by this page's generator, then sorted ascending as text. Numbers are creation order: green sits where it was created, red has moved. The orange characters are the time part. “Copy link to this comparison” opens these same five IDs again. The IDs you generated above are not on the card.
How to Use
- Pick a typeIf you only need IDs that never collide or that you show to outsiders, take UUID v4. If the ID is a database primary key and rows should land in insertion order — or you want the creation time readable from the ID — take UUID v7 (fits an existing UUID column) or ULID (shorter, 26 characters).
- Set the count and formatAsk for 1 to 100. Open “Format” to choose the shape: “Quoted” for a SQL INSERT, “JSON array” for code. Common combinations are one tap on the preset buttons under the result, which set everything and generate.
- Generate and copyPress Generate and the values appear at once; “Copy all” at the top right of the result puts the batch on your clipboard. If you reuse a setup, bookmark it with “Copy URL for these settings” — every visit then lists fresh IDs.
About This Tool
A UUID v4 is 128 bits of which 122 are random. Six bits are spent on the version (4) and the variant; everything else is entropy (RFC 9562 §5.4). That is the whole point: any machine can mint one without asking a central server, and collisions stay negligible (by the birthday approximation you would need on the order of 1014 IDs before a single collision reaches a one-in-a-billion chance). This page draws its randomness from crypto.getRandomValues(), the browser's cryptographic RNG. It does not use Math.random(). UUIDs built on Math.random() can be predicted, which rules them out anywhere the ID must not be guessable.
A UUID v7 is a UUID with the clock in front, standardised by RFC 9562 in May 2024. The first 48 bits are Unix time in milliseconds, then come the version (7) and variant, and 74 more bits (§5.7). The RFC designs v7 to sort as opaque raw bytes and intends the text form to sort lexicographically as well (§6.11). It is 36 characters and fits the same column type as any UUID, so it is the way to make an existing uuid primary key time-ordered. The RFC gives three ways to stay ordered within one millisecond; this tool treats the trailing 74 bits as a number and advances it by a random step (1 to 232) for each value (§6.2 Method 2 — the RFC advises against incrementing by 1 when unguessability matters, because the next value becomes predictable).
ULID popularised the same idea before the RFC. Of its 26 characters, the first 10 encode the creation time (Unix milliseconds, 48 bits) and the remaining 16 are random (80 bits), written in Crockford's Base32. The alphabet drops the ambiguous I, L, O and U, so the values survive being read aloud or copied by hand. Within one millisecond this tool follows the monotonic rule from the ULID spec and increments the random part by one for each new value, so a batch of 100 still sorts in creation order (a naive implementation leaves every timestamp prefix identical and lets the random tail decide the order).
Real-world example: v7 is now built into major platforms. PostgreSQL 18 ships uuidv7() as a standard function, and uuid_extract_timestamp() reads the time back out of a v7 (PostgreSQL's uuidv7() also embeds a sub-millisecond timestamp). Python 3.14 added uuid.uuid7(), which keeps a 42-bit counter for monotonicity within a millisecond. Same version, different ways of ordering IDs within one millisecond.
As a primary key, a time-ordered ID (v7 or ULID) often wins. UUID v4 is uniformly random, so every insert lands in a different place in a B+tree index, which costs page splits and cache misses. With the time in front, inserts cluster near the end of the index (RFC 9562 §6.11 also notes the better index locality of time-ordered IDs). The trade-off is that both v7 and ULID publish their creation time to anyone who has them; use v4 when that timing is sensitive.
Watch the spelling. RFC 9562 §4 says the hex letters of a UUID may be all upper case, all lower case or mixed (the older RFC 4122 said they are output in lower case and accepted in either case on input). This tool writes UUIDs in lower case as its own default, matching RFC 4122's output rule and the output of libraries such as Python's uuid — the current standard does not require it. Windows GUIDs are traditionally written upper case inside braces {…}, and MySQL BINARY(16) setups often use the 32-character hyphen-free form. ULIDs are usually written in upper case (the spec itself is case-insensitive). Keep one spelling per system. Wherever IDs are compared as strings, the same ID will be treated as two, and even v7 stops sorting in creation order once cases are mixed (in character codes A–F come before a–f).
Everything happens on this page. No server hands out the numbers, so none of these values end up in someone else's log. You can also call the tool straight from a URL: /en/uuid/?type=v7&count=20&format=json (type=uuid|v7|ulid, count=1–100, format=plain|json|csv|quoted, case=upper|lower, hyphens=0, braces=1). “Copy URL for these settings” builds exactly this kind of URL. A comparison-card link has the form #cmp=…; everything after the # stays out of the request that opens the page.
Sources (checked 2026-11-10)
- Upper, lower or mixed case are all allowed (§4); 122 random bits in v4 (§5.4); v7 layout (§5.7); monotonicity methods (§6.2); sorting and index locality (§6.11): RFC 9562 “Universally Unique IDentifiers (UUIDs)” (May 2024, obsoletes RFC 4122) rfc-editor.org/rfc/rfc9562.html
- “The hexadecimal values "a" through "f" are output as lower case characters and are case insensitive on input.” (§3): RFC 4122 rfc-editor.org/rfc/rfc4122.html
- ULID layout (48-bit time, 80-bit randomness, 26 characters, Crockford's Base32, case-insensitive) and monotonicity within a millisecond: ULID spec github.com/ulid/spec
- uuidv7() and uuid_extract_timestamp(): PostgreSQL 18 documentation, “UUID Functions” postgresql.org/docs/current/functions-uuid.html
- uuid.uuid7() (added in 3.14, 42-bit counter); str(uuid) and UUID.hex are lower case: Python documentation, “uuid” docs.python.org/3/library/uuid.html
From AI Agents
The same generator ships as the uuid_generate tool of the MCP (Model Context Protocol) server @first-ch/tools-mcp, so an AI agent can call it directly instead of driving a browser (UUID v4, UUID v7 and ULID) — faster when you are seeding test data or drafting a migration. See Using these tools from AI agents for setup.
Install
claude mcp add firstch-tools -- npx -y @first-ch/tools-mcp
Examples
# ten UUID v4 values uuid_generate(type="uuid", count=10) # 100 ULIDs (monotonic within a millisecond, so they stay in creation order) uuid_generate(type="ulid", count=100) # take them as a JSON array / as upper-case values without hyphens uuid_generate(type="uuid", count=5, format="json") uuid_generate(type="uuid", count=5, hyphens=false, uppercase=true)