By the Withuse team · Updated
UUID versions at a glance
| Version | Based on | Best for |
|---|---|---|
| v4 | Random (122 bits) | General-purpose unique IDs — the safe default |
| v7 | Unix timestamp + random | Database primary keys, time-sortable IDs |
| v1 | Timestamp + node | Legacy systems that expect Gregorian-time UUIDs |
| v5 | SHA-1 of namespace + name | Deterministic IDs — same input, same UUID |
| v3 | MD5 of namespace + name | Deterministic IDs where v3 is required for compatibility |
Tools
- UUID decoder — check version, variant & extract the timestamp
- UUID vs auto-increment — which primary key should you use?
- Is a UUID secure? — guessability, leakage and token use
- UUID vs MongoDB ObjectId — 12 bytes against 16
- UUID vs NanoID — shorter and higher entropy
Guides
- UUID v4 vs v7 — which should you use?
- UUID vs ULID — differences and trade-offs
- How to generate a UUID in Python
- How to generate a UUID in JavaScript & Node.js
- UUID vs GUID — is there any difference?
- UUID in PostgreSQL — gen_random_uuid & uuidv7
- How long is a UUID? Format & structure
- UUID regex patterns + live tester
- UUID collision probability — the maths, with a calculator
- How to generate a UUID in Go
- UUID in MySQL — BINARY(16) & the swap flag
- How to generate a UUID in Java
- UUID in C# — Guid.NewGuid & CreateVersion7
Standards & references
Every version this tool produces follows RFC 9562 (2024), which supersedes RFC 4122 and introduced the time-ordered versions 6, 7 and 8. Randomness comes from the browser's Web Crypto API, and the predefined namespaces used for v3 and v5 are the DNS, URL, OID and X.500 constants listed in the IANA UUID registry.
Frequently asked questions
What is a UUID?
A UUID (Universally Unique Identifier) is a 128-bit value used to identify information uniquely without a central authority issuing it. In text form it is 36 characters: 32 hexadecimal digits arranged in five groups of 8-4-4-4-12 and separated by hyphens, as in 550e8400-e29b-41d4-a716-446655440000. Two of those digits are not payload — one encodes the version, another the variant — so an implementation can tell how a given value was produced. The format is standardised in RFC 9562, which replaced RFC 4122 in 2024 and added the time-ordered versions 6, 7 and 8. Because any machine can mint one independently and still expect it to be globally unique, UUIDs are the default choice for distributed systems, database keys and API resource identifiers.
Which UUID version should I use?
Use v4 for general-purpose random identifiers: it fills 122 bits with cryptographically secure randomness and reveals nothing about when or where it was created. Use v7 when the value will become a database primary key — its leading 48-bit millisecond timestamp makes new rows sort last, so inserts append to the index instead of scattering across it, which preserves write performance as a table grows. Use v5 (or v3, if an existing system requires MD5) when the same input must always derive the same identifier, such as when two services independently map the same entity without a shared database. Versions 1 and 6 exist mainly for legacy compatibility; new code should reach for v7 instead.
Is this UUID generator safe to use?
Yes. Every value is generated locally in your browser through the Web Crypto API, the same cryptographically secure random source that browsers expose for key material, so the output is unpredictable rather than merely random-looking. Nothing you type or generate is transmitted: there is no API call behind the Generate button, no server-side logging, and no analytics event carrying the values. That also means the page keeps working offline once loaded, and you can safely use it for identifiers destined for production systems. The only network request the site makes is a cookie-less Cloudflare Web Analytics beacon that counts page views, described in our privacy policy.
Are UUIDs really unique?
In practice, yes — collisions are astronomically unlikely rather than impossible. A v4 UUID carries 122 random bits, giving roughly 5.3 undecillion (5.3 × 10^36) possible values. Applying the birthday-paradox formula, you would need to generate about 2.7 quintillion (2.7 × 10^18) of them before reaching a 50% chance of a single duplicate; at a billion UUIDs per second that takes on the order of 85 years. Real-world duplicate reports almost always trace back to an implementation defect instead of exhausted entropy: a seeded pseudo-random generator, a fork that copies the random state, or a virtual machine snapshot restored repeatedly. Use a library backed by a cryptographic random source and the theoretical bound holds.
What is the difference between UUID and GUID?
There is no difference in the value itself: GUID (Globally Unique Identifier) is Microsoft's name for the same 128-bit UUID defined by RFC 9562, and any valid GUID is a valid UUID. What differs is convention and, in one place, byte order. Microsoft tooling often prints uppercase and wraps the value in braces, as in {550E8400-E29B-41D4-A716-446655440000}, while the RFC canonical form is lowercase and unbraced. More consequentially, .NET's Guid.ToByteArray() stores the first three fields little-endian, so the same identifier serialises to different bytes than an RFC-ordered implementation — a real source of bugs when exchanging binary UUIDs between .NET and other platforms.