UUID Generator
A UUID (universally unique identifier) is a 128-bit ID written as 32 hex characters — the familiar xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx shape. This free UUID generator creates version 4 (random) and version 7 (time-ordered) UUIDs in bulk, with uppercase/lowercase and hyphen options, plus an inspector that reads any UUID's version, variant, and embedded timestamp. Everything runs 100% in your browser using crypto.getRandomValues — a real cryptographic random source, never Math.random().
Inspect a UUID
100% client-side — nothing is uploaded or stored.
What a UUID is
A UUID packs 128 bits into five hyphen-separated groups. Two positions carry meaning; the rest is randomness (or a timestamp):
| Segment | Example | Meaning |
|---|---|---|
| 8 hex chars | 550e8400 | Random (v4) or timestamp high bits (v7) |
| 4 hex chars | e29b | Random (v4) or timestamp low bits (v7) |
| 4 hex chars | 41d4 | First char is the version (4 or 7) |
| 4 hex chars | a716 | First char encodes the variant |
| 12 hex chars | 446655440000 | Random bits |
The version nibble tells you how the UUID was made; the variant field (almost always 8, 9, a, or b) marks it as an RFC 4122 UUID. The inspector above reads both, and decodes the embedded creation time from v7 UUIDs.
UUIDs are standardized by RFC 9562 (published 2024, obsoleting RFC 4122 and adding versions 6, 7, and 8). The canonical text form is lowercase hex with hyphens, but conforming parsers must accept uppercase and the compact 32-character form as well.
Common use cases
- Database primary keys — v7 keeps new rows physically adjacent, avoiding the index fragmentation random v4 keys cause.
- Distributed systems — services generate IDs independently with no coordinator and no collisions.
- Request tracing — stamp each request with a v4 ID to follow it across logs and microservices.
- File and upload names — unique names that never overwrite each other.
- Test fixtures — bulk-generate realistic IDs for seed data and automated tests.
How to use it
- Pick v4 (random) or v7 (time-ordered).
- Set how many you need (up to 1,000) and toggle uppercase/hyphens.
- Click Generate, then copy or download the list.
- To analyze an existing UUID, paste it into the inspector.
UUID v4 vs v7
v4 is 122 bits of pure randomness — unpredictable and with no information embedded, which is exactly what you want for tokens and request IDs. v7 (RFC 9562, 2024) puts a millisecond Unix timestamp in the first 48 bits, so IDs sort in creation order while the remaining 74 random bits keep collisions away. That ordering is a genuine performance win for database indexes: time-ordered inserts append to the index instead of scattering writes randomly across it. The tradeoff is minor information leakage — anyone can read roughly when a v7 ID was created — so stick with v4 where creation time should stay private.
Are UUIDs really unique?
Uniqueness is probabilistic, not guaranteed — but the probabilities are absurdly in your favor. With 122 random bits, the birthday-paradox math says you'd need around 2.7 quintillion generated IDs before a collision becomes likely. To put it plainly: generating a billion UUIDs per second for 100 years still gives you roughly a coin flip's chance of a single duplicate. v7 is even safer in practice, since IDs created at different milliseconds can't collide at all. So no, not mathematically guaranteed — but safe to build on.
Frequently asked questions
- What is a UUID used for?
- Anywhere you need an identifier that won't collide: database primary keys, distributed systems, file names, request IDs, and API resource IDs. Because generation needs no central coordination, two servers can mint IDs independently without ever clashing in practice.
- Should I use UUID v4 or v7?
- Use v7 for database primary keys — its time-ordered prefix keeps inserts clustered together, which indexes love. Use v4 for everything else: request IDs, file names, and cases where you don't want the creation time embedded in the ID.
- Are UUIDs guaranteed to be unique?
- Not mathematically, but close enough to treat as yes: a v4 UUID has 122 random bits, so you'd need to generate about a billion UUIDs per second for a century before reaching even a 50% chance of one collision. v7 adds a timestamp on top, making accidental collisions even less likely.
- Can I use a UUID as a password or API token?
- A v4 UUID from a cryptographic generator (like this tool's crypto.getRandomValues) has 122 bits of randomness — fine for non-critical tokens and request IDs. For real credentials and API keys, prefer a longer dedicated secret (256 bits) from a proper secrets generator instead.
- Does uppercase vs lowercase matter?
- No. Hex is case-insensitive, so 550E8400-E29B-41D4-A716-446655440000 and its lowercase form are the same UUID. Lowercase is the conventional output (RFC 4122), but any parser must accept both.
- With or without hyphens — which is correct?
- Both represent the same value. The hyphenated 8-4-4-4-12 form is the canonical text representation; the 32-character compact form is common in URLs and some databases. If a system rejects one, try the other before assuming the UUID itself is wrong.
- Is anything uploaded when I generate UUIDs?
- No. Generation and inspection run entirely in your browser using the WebCrypto API's crypto.getRandomValues — the operating system's cryptographic random source. Nothing leaves your device.