UUID Generator

Most UUID tools online do one thing. They hand you a v4, a pile of random hex, and call it a day. That covers the common case, but the moment you need anything else you are stuck hunting for a second site. This one does the whole family: v4 random, v7 time-ordered, v1, a proper v5 namespace generator, and the reserved Nil and Max values. Pick a version, get exactly what you came for, and everything runs in your browser so nothing you type ever leaves your machine.

The two people actually come looking for and rarely find are v7 and v5. v7 is the one you want for database primary keys, because it starts with a timestamp and follows it with a counter, so newer IDs always sort after older ones and a hundred generated in the same millisecond still come out in the order they were made. v5 is the deterministic member of the family. Feed it a namespace and a name and it gives back the same UUID every single time, which is how you turn a URL or a username into a stable ID with no lookup table behind it. Free generators almost never do v5, and plenty of them botch v1 by leaking the real network address of whatever machine made it. Ours uses a random node for v1, so no hardware fingerprint rides along.

1. Pick a version at the top. v4 is selected by default and is the right choice for most work.
2. For v4, v7, or v1, set How many and click Generate. A fresh batch appears right away, up to 100 at a time.
3. For v5, choose a namespace (DNS, URL, OID, X.500, or paste your own) and type one name per line. You get one UUID back per name, in the same order.
4. Flip the formatting toggles to match your target. Uppercase for systems that want capitals, Remove hyphens for a compact 32-character string, Wrap in quotes to drop straight into code or a CSV cell.
5. Hit Copy to grab the whole list, one per line. Share saves your exact setup in the link, so you can bookmark a specific version and format and come back to it later.

Nil and Max are their own choice in the picker. They are the two reserved special values, and the tool just shows both so you can copy one without typing sixteen zeros by hand.

v4, the random default

v4 is 122 bits of pure randomness with a couple of marker bits stamped in to say "I am a v4." No timestamp, no machine info, nothing embedded at all. That is exactly why it is the safe pick for almost everything. A v4 in a public URL or an API response gives away nothing about your system. Every language and database supports it, and there is nothing to configure. Not sure which version you need? You need this one.

v7, the one for database keys

Random v4 keys scatter all over a database index, and on a big write-heavy table that fragmentation drags your inserts down. v7 fixes it by putting a millisecond timestamp in the front of the value, then a counter, then randomness. The result still behaves like a UUID, generated anywhere with no central coordinator, but because the leading bits climb over time the IDs land in the order they were created. The counter is the part most generators skip, and it is what keeps a whole batch minted inside a single millisecond in order rather than merely looking like it. Your index stays tidy and inserts stay quick. If you are choosing primary keys for a new table today, v7 is usually the smarter call. The one thing to know is that it exposes a rough creation time, so skip it if that timestamp is sensitive.

v5, deterministic from a name

v5 is the odd one out, and the most useful once it clicks. It is not random. You give it a namespace, which is itself a UUID, and a name, which is any text. It runs both through a SHA-1 hash and out comes a UUID. The same inputs always produce the same output, on any machine that follows the standard, which is the whole point of it.

Say you want a stable ID for every page on a website. Run each URL through v5 with the URL namespace and you get consistent IDs with no table of mappings to keep in sync. Two services that never talk to each other will compute the identical ID for the same input, which is how distributed systems agree on identifiers without comparing notes. The four standard namespaces (DNS, URL, OID, X.500) are built in, and you can paste a custom one if your project defines its own. This is the part free tools skip, and it is the reason a lot of people end up writing the hashing themselves.

v1 and the Nil and Max values

v1 is the original time-based scheme from the old spec. It combines a timestamp with a node identifier, and classic implementations used the machine's real network address for that node, which quietly told the world which server minted the ID. We generate a random node instead and set the bit that marks it as random, so you get a valid v1 with none of that exposure. Mostly you reach for v1 only when an older system already expects the format.

Nil is all zeros, the UUID version of an empty value, handy as a default or a "not set yet" placeholder. Max is all ones, its newer counterpart. Neither is something you really generate, so the tool keeps both a click away.

The reason you can trust a UUID as unique without any central registry checking is the size of the space. A v4 has roughly 5.3 x 10^36 possible values, about 5.3 undecillion. To reach even a 50 percent chance of one repeat you would have to generate a billion per second for around 85 years. No real workload comes near that, so you treat collisions as a solved problem and move on. That math only holds if the randomness is genuinely strong, which is why this tool draws from your browser's cryptographic generator, not the weak everyday random function quick web toys reach for.

One caveat is worth stating clearly. A v4 UUID is hard to guess, but it is still not a secret, because systems log them, cache them, and pass them around in the open. They are made for identifying things, not guarding them, so never use one as a password, an API key, or an access token. For those, use a tool built for secrets.