UUID Generator
Generate random version-4 UUIDs in your browser.
Generate 1 to 10 at once.
UUIDs are created locally with the browser’s cryptographic random source and never leave this device.
Results
Generated in your browser with the Web Crypto CSPRNG (random version 4) and never transmitted. Each value is a fresh 122-bit random UUID.
How the UUID generator works
A UUID is a 128-bit identifier written as 32 hexadecimal digits in five dash-separated groups: 8-4-4-4-12, like 123e4567-e89b-42d3-a456-426614174000. This tool produces version 4 UUIDs, the random kind, defined by RFC 9562 (which replaced RFC 4122).
The recipe is simple. The browser draws 16 random bytes from its cryptographic random source (crypto.getRandomValues), never a general-purpose pseudo-random function. Two small adjustments then mark the value so any reader can identify it:
- The high nibble of the 7th byte is forced to
0100in binary, which is the digit 4. That is the version, and it always lands as the 13th character of the string. - The top two bits of the 9th byte are forced to
10. That constrains the 17th character to one of 8, 9, a, or b, which records the modern variant.
Everything else stays random. After those two edits, 6 bits are fixed and 122 bits remain random. The 16 bytes are written out as lowercase hexadecimal and the four dashes are inserted to give the canonical form.
Worked example
Start with 16 random bytes. To make the structure visible, imagine they all came back as zero:
| Step | Result |
|---|---|
| 16 raw bytes (all zero) | 00000000000000000000000000000000 |
| Force version on byte 7 | 0x00 & 0x0f | 0x40 = 0x40 |
| Force variant on byte 9 | 0x00 & 0x3f | 0x80 = 0x80 |
| Insert dashes | 00000000-0000-4000-8000-000000000000 |
The 13th character is 4 (the version) and the 17th character is 8 (the variant), exactly as the standard requires. In real use the other 30 characters are random hexadecimal rather than zeros, for example 9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d. Notice the 4 and the b sitting in those two fixed positions while the rest varies.
The randomness is what makes UUIDs safe to mint independently. With 122 random bits there are roughly 5.3 x 10^36 possible values, so two machines generating UUIDs at the same moment, with no coordination between them, will not clash in any practical lifetime.
How to use it
- Press Generate to mint a fresh random UUID on demand. Each press draws new random bytes.
- Set How many to produce a batch of up to ten at once when you need several identifiers.
- Use a row’s Copy button to grab a single value, or Copy all to copy the whole batch, one per line.
- Paste the value wherever you need a stable key: a database row, an API request id, a file name, or a distributed message.
- The value is lowercase, which most systems treat the same as uppercase. Convert the case yourself if a strict consumer demands it.
Limitations
A version 4 UUID is built for uniqueness, not for secrecy or ordering. It is not a secret token on its own: anyone who sees it can copy it, so do not use a raw UUID as a password or an unguessable capability without additional protection. Because the value is random, it carries no embedded timestamp, so a list of v4 UUIDs has no meaningful sort order. If you need identifiers that sort by creation time, look at a time-ordered scheme such as UUID version 7 instead. Finally, while collisions are astronomically unlikely, they are not mathematically impossible. Systems that demand an absolute guarantee should still enforce a uniqueness constraint at the point of storage.
Frequently asked questions
Are these UUIDs generated on a server or saved anywhere?
No. Every UUID is created inside your browser using its built-in cryptographic randomness, and nothing is sent to a server, logged, or stored. Close the tab without copying and the values are gone. That makes the tool safe to use for secrets you do not want to leave your device.
What does the version 4 in a UUID actually mean?
Version 4 means the identifier is built almost entirely from random bits rather than from a timestamp or MAC address. Of the 128 bits, four are fixed to mark the version (the digit 4) and two mark the variant, leaving 122 random bits. You can spot a v4 UUID because the 13th character is always 4 and the 17th is 8, 9, a, or b.
How likely is a collision between two random UUIDs?
Vanishingly unlikely. With 122 random bits there are about 5.3 times 10 to the 36th possible values. You would need to generate on the order of a billion UUIDs per second for roughly 85 years before the chance of a single duplicate reaches even 50 percent. For everyday use you can treat them as unique without a central registry.
Why are some characters fixed instead of fully random?
The standard reserves a few bits so any reader can tell how a UUID was made. The version nibble (the 13th character) records that it is random, version 4. The variant bits (the start of the 17th character) record the layout, the modern RFC 9562 variant, so the value reads as 8, 9, a, or b. The other 122 bits are random.
Can I generate more than one at a time?
Yes. Use the count selector to produce up to ten at once, copy any single value with its own button, or copy the whole list with Copy all. Each value is generated independently from fresh random bytes, so they are all distinct.
Is a UUID the same as a GUID?
Effectively yes. GUID is Microsoft's name for the same 128-bit identifier. A version 4 UUID and a random GUID follow the same 8-4-4-4-12 hexadecimal format, so a value from this tool is a valid GUID too. This tool always outputs lowercase, which most systems accept interchangeably with uppercase.