Generate UUID v1, v3, v4, v5, v6 and v7, ULID, NanoID, CUID2 and Snowflake IDs, and read any of them back
Initializing in your browser…
Generate QR codes and check each one scans by decoding it back before you download it
Generate linear barcodes with the quiet zone each standard requires, and read the bars back to check they are right
Build a colour harmony that holds its lightness by rotating hue in OKLCH, with the contrast of every pair, a perceptually even tint and shade ramp, and what a colour blind reader sees
These are your primary keys, so they have to be unique, and you would rather they did not scatter every insert across the index.
Settings
UUID v7, four of them, all made in the same millisecond
Generated
0198f199-1c00-7000-b525-06d2bc608d92 0198f199-1c00-7001-a8ec-e27b2fd07f29 0198f199-1c00-7002-b9de-b87197400f7b 0198f199-1c00-7003-aee6-3220a9e5145d
The first twelve hex digits, 0198f199-1c00, are the Unix millisecond, identical across all four because they were made in the same one, so these sort by time as plain strings. The `7` after that is the version. The three digits following it run 000, 001, 002, 003: a counter that increments while the clock has not moved, which is what keeps identifiers made inside one millisecond in the order they were made. Without it a batch like this sorts arbitrarily, which defeats the point of choosing a time-ordered version at all. The `b` and `a` starting the fourth group are the variant bits, and everything after them comes from `crypto.getRandomValues`. The tool also generates v1, v3, v4, v5, v6, ULID, NanoID, CUID2 and Snowflake, and reads any of them back, including the timestamp inside a v1, v6, v7, ULID or Snowflake.
Generate identifiers in ten formats and read any of them back: UUID v1, v3, v4, v5, v6 and v7 from RFC 9562, plus ULID, NanoID, CUID2 and Twitter-style Snowflake. Pick a format, set a count, and every value is produced from `crypto.getRandomValues`, the platform’s cryptographic generator. The Inspect mode takes any identifier you paste, works out what it is, and takes it apart: the version, the variant, the timestamp inside a v1, v6, v7, ULID or Snowflake, and the sixteen octets with the version and variant bytes marked.
Everything is read and written on the sixteen octets rather than on the hyphenated string. That sounds like an implementation detail and is not: reading a version by taking character 14 and a variant by taking character 19 works only for one exact spelling, and the string positions are one off from the octet boundaries in a way that is easy to get wrong. Working on the octets is also what lets the tool accept a UUID in braces, with a urn:uuid: prefix, in upper case, or with the hyphens missing, and still say what it is.
RFC 9562 defines seven versions and this tool generates six of them, leaving out v2, which is a DCE security variant almost nobody uses. Which one you want depends on one question: does the order matter? A v4 is 122 random bits and sorts arbitrarily, which is fine for a value nothing indexes. A v7 puts the Unix millisecond in the first 48 bits, so a batch sorts by time as plain strings, which keeps database inserts at the end of an index instead of scattered through it. A v6 does the same job by reordering v1’s time fields; a plain v1 does not sort, because its string starts with the low 32 bits of the clock, which wrap every 429.5 seconds, and the tool says so next to each format rather than lumping them together as "time based".
The time-ordered versions are monotonic within a millisecond, which is the part that is usually missing. A generator that redraws its random field every call produces values that are unique but land in an arbitrary order when several are made in the same millisecond, and that is exactly the case a time-ordered identifier exists to handle. Here v7 carries a counter in its rand_a field, the way RFC 9562 section 6.2 method 1 describes; v1 and v6 keep a stable clock sequence and node; ULID increments its previous random field, which its own specification calls the monotonic factory; and Snowflake moves its timestamp on when the 12-bit sequence fills, rather than reusing a sequence number. Four thousand v7 made in one millisecond come out unique and in order, and the panel says on screen whether the batch you are looking at sorts in the order it was made.
v3 and v5 are the deterministic ones: MD5 or SHA-1 over a namespace UUID followed by a name, so the same input always gives the same UUID and nothing has to be stored to look it up again. Pick one of the four namespaces RFC 9562 defines (DNS, URL, OID, X.500) and type a name. These are checked against digests computed independently: v5 of "www.example.com" in the DNS namespace is 2ed6657d-e927-568b-95e1-2665a8aea6a2 and v3 of the same is 5df41881-3aed-3515-88a7-2f4a814cf09e, and the tool produces both.
There is a chi-square test built in, which draws twenty thousand identifiers and checks that every character occurs equally often, reporting the statistic against the published 0.01 critical value. It is honest about what that proves: a chi-square cannot tell a cryptographic generator from `Math.random`, which passes it comfortably and is still guessable from a handful of outputs. The source is therefore stated separately, because it is the part that actually matters.
A v1 also carries a node identifier. When that node is not a real network address, RFC 9562 section 5.1 requires the multicast bit of its first octet to be set, so a generated node can never collide with a hardware one; the generator here sets it and keeps the same node for the life of the page, because a v1 is meant to be ordered by time and node and one that changes every call is not.
Generate v7 or ULID. Both put the timestamp first, so consecutive inserts land next to each other in a B-tree instead of all over it, and both stay ordered when several are made in the same millisecond.
v5 in the DNS or URL namespace turns a name into a UUID deterministically, so the same input always maps to the same identifier and nothing has to be stored to look it up again.
Paste it into Inspect. The version and variant come off the octets, and a v1, v6, v7, ULID or Snowflake tells you when it was made.
Each format states how many bits are free and, from the birthday bound, roughly how many identifiers it takes before a collision becomes an even chance.
v4 when nothing has to be ordered. v7 when the identifiers are database keys, because they sort by time and keep index inserts local. v5 when the identifier has to be derivable from a name. v1 is worth avoiding for anything new: it does not sort as a string, and it was designed to embed a MAC address.
Because for that format it does not. A v4 is random, so consecutive values land in an arbitrary order. The line above the list is measured on the batch on screen, not assumed from the format.
For v4, the birthday bound puts an even chance of one collision at roughly 2.3 billion billion identifiers, so no. The formats that carry a timestamp are also protected by a counter, so several made in the same millisecond cannot repeat.
That every character occurs about as often as every other, which rules out a broken alphabet or a modulo bias. It does not prove the values are unguessable: Math.random passes the same test and its state can be recovered from a few outputs. The bits here come from crypto.getRandomValues, and that is the claim worth making.
Snowflake IDs are read against an epoch, and this tool uses Twitter’s, 4 November 2010. Discord and others chose their own, so the instant shown is off by the difference between the two. The panel says which epoch it used.
Sixteen octets, written as 32 hexadecimal digits in five groups of 8-4-4-4-12. The high nibble of octet 6 is the version and the high bits of octet 8 are the variant; the Inspect panel marks both.
Conversions run on your device in JavaScript. The values you enter are never sent over the network.