UUID Generator
Click below to generate a random, version-4 UUID you can use immediately.
- Free
- No account
- Runs in your browser
- Nothing uploaded
Press Generate UUID — the value is created in your browser with crypto.randomUUID() and never sent anywhere.
Runs entirely in your browser — your input is never uploaded, logged, or stored.Privacy policy
What is UUID Generator?
A UUID (Universally Unique Identifier) is a 128-bit value used to identify information without a central authority handing out IDs. This tool generates version 4 UUIDs, the most common variant, where 122 of those bits are chosen at random — the remaining 6 bits are fixed to mark the version and variant, which is why every UUID v4 looks like xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx, with a 4 in the same position and y always one of 8, 9, a, or b.
What that randomness buys is generation without coordination. An auto-incrementing integer needs an authority — a database sequence, a counter service — that hands out the next value and remembers what it gave out last. A UUID needs nothing: two machines with no connection between them can each mint thousands, and the values will not collide. The cost is that a v4 UUID tells you nothing. It does not sort, it holds no timestamp, no counter and no checksum, and you cannot tell by looking whether it was created a second ago or five years ago. That is deliberate — anything you could read out of it would be something it had leaked.
Generation uses the Web Crypto API's cryptographically secure random number generator (crypto.randomUUID()), not a plain pseudo-random function, so the output is suitable for security-sensitive identifiers, not just display IDs.
That distinction matters more than it sounds. Math.random() — what a lot of online generators and copy-pasted snippets use — is fast but predictable: it is seeded from a small internal state, and an observer who sees enough output can work out what comes next. crypto.randomUUID() draws from the operating system's entropy pool through the same interface used for cryptographic keys. The two produce identical-looking strings, which is exactly why it is worth saying which one you are getting.
| UUID v1 | UUID v4 (this tool) | |
|---|---|---|
| Based on | Timestamp + MAC address | Pure randomness (122 random bits) |
| Can leak info | Yes — creation time and machine identity | No |
| Sortable by creation time | Yes, roughly | No |
| Typical use | Legacy systems, distributed logging | Database keys, API IDs, general use |
Worked examples
- Example output: 3fa85f64-5717-4562-b3fc-2c963f66afa6 — note the fixed 4 and the b in the third and fourth groups.
- Shape: 8-4-4-12 hexadecimal characters, 36 in total including the four hyphens.
- The version nibble is always 4 and the variant nibble is always one of 8, 9, a or b — so of the 32 hex characters, 30 carry randomness and 2 are fixed by the specification.
- Output is always lowercase, which is the form RFC 4122 specifies for generated UUIDs. Comparisons should still be case-insensitive, because the same spec requires readers to accept uppercase input.
How to use UUID Generator
- Click "Generate UUID".
- Copy the value using the copy button.
- Generate again for a new one — there's no limit and nothing is stored.
Common errors
- "I got the same UUID twice" — with 122 random bits, a collision is astronomically unlikely (you'd need roughly a billion UUIDs a second for about 85 years before a 50% chance of one collision); if it ever happens, check that your browser's random number generator itself is intact.
- "I need a UUID without dashes" — strip them yourself if your target system requires the 32-character unformatted form; the canonical, dashed form is what's generated here since it's what RFC 4122 specifies.
FAQ
Is this UUID generator free to use?
Yes, generation is unlimited and free, and runs entirely in your browser.
Does the UUID get sent to a server or stored anywhere?
No. Generation happens client-side using your browser's built-in crypto.randomUUID() function — nothing is transmitted or logged.
What's the difference between UUID v4 and other UUID versions?
UUID v1 encodes the current timestamp and the generating machine's network identifier, which can leak information about when and where it was created. UUID v4 is purely random, which is why it's the standard choice for most applications today. This tool generates v4 only.
Can I use a UUID as a database primary key?
Yes, it's a common pattern — UUIDs avoid the coordination problem of auto-incrementing IDs across distributed systems, at the cost of being larger (16 bytes) and less index-friendly than a plain integer. Store it in a native uuid column where your database has one: Postgres stores that as 16 bytes, while the same value as text is 36. The index-friendliness point is the real cost — random v4 values arrive in no order, so inserts scatter across the index rather than appending to the end.
Can I generate several UUIDs at once?
Not here — this tool generates one at a time, and generating again is a single click with no limit. If you need a thousand for a fixture, the honest answer is that a loop in your own language is faster than any web page: crypto.randomUUID() in Node, uuid4() from Python's uuid module, or gen_random_uuid() directly in Postgres.
Is a UUID v4 safe to use as a password reset token or session ID?
It is unguessable enough — 122 random bits from a cryptographic source is more entropy than most session tokens carry. The caution is not about the randomness but about the handling: a token also needs an expiry, single use, and storage as a hash rather than in plain text. A UUID gives you the unpredictable part and none of the rest, so use your framework's token support if it has one.
What about UUID v7 — should I use that instead?
Quite possibly, and this tool does not generate it. UUID v7 puts a millisecond timestamp in the leading bits, so values sort roughly by creation time, which fixes the database-index problem v4 creates while keeping the rest random. If your ids are primary keys in a large, write-heavy table, v7 is worth looking at. For everything else — API identifiers, correlation ids, file names — v4 is still the sensible default.
Why is the output always lowercase?
RFC 4122 specifies that generated UUIDs are output in lowercase hexadecimal, while software reading a UUID must accept either case. So lowercase is correct on the way out, and your comparisons should be case-insensitive on the way in. If a system you are integrating with insists on uppercase, upper-casing the string is safe — it is the same identifier.
Does this work offline, or on an internal network without HTTPS?
It works offline once the page is loaded, since generation is entirely local. HTTPS does matter though: crypto.randomUUID() is only available in a secure context, which means HTTPS or localhost. On a plain http:// page served from an internal IP the function is not exposed at all.
Related tools
Prefer AllUtil on Google
One click adds AllUtil to your Google preferences. You'll see our tools highlighted with a Preferred badge in Search and AI answers.