Developer

UUID Generator

Generate random v4 UUIDs and GUIDs in bulk, copyable individually or as a list, computed locally in your browser with no server round-trip for a single one.

UUID v4 generator

Also called a GUID— “Globally Unique Identifier” is Microsoft’s name for the exact same 128-bit value a UUID is; the two terms describe one format, not two. This box is generating a version 4 (random) id — see “UUID v4 vs v7” below for which one you actually want.

Your v4 UUID

Generating…

Generated in this browser and nowhere else — there is no network request behind this button, so no server, including ours, ever sees this id before you paste it. That matters the moment it is about to become a real database key or an API token: nobody else has had the chance to see it first.

Bulk UUID generator

UUID validator

Paste any UUID or GUID above — with or without hyphens, braces and all — to see whether it’s valid and which version it claims to be.

Nil UUID

00000000-0000-0000-0000-000000000000

Pick a version above, or accept the v4 (random) default, and a fresh id appears immediately — generated by your browser's own cryptographic random number source, never sent anywhere. Turn on bulk generation to get up to 500 at once, formatted the way whatever you're pasting into expects, and use the validator at the bottom to check a UUID or GUID someone else handed you.

GUID generator: is a GUID the same as a UUID?

Yes — completely. "UUID" and "GUID" name the identical 128-bit value; the difference is only which world you learned the term in. UUID (Universally Unique Identifier) is the name used by the original OSF specification and by most languages, Unix-family tools and RFCs; GUID (Globally Unique Identifier) is Microsoft's name for the same thing, and it's the term you'll see in C#, .NET, SQL Server's UNIQUEIDENTIFIER column type, and the Windows registry. The one place the two worlds visibly differ is formatting convention, not the underlying value: a GUID pasted from SQL Server or the registry often arrives wrapped in curly braces, like {550e8400-e29b-41d4-a716-446655440000} — which is exactly why the "Wrap in braces" option below exists, and why the validator strips a leading and trailing brace before checking a pasted value rather than rejecting it as malformed.

UUID v4 generator: what "random uuid v4" means

Every id this tool generates states its version out loud, because "a UUID" on its own is ambiguous — the specification defines eight different schemes for building one, and they are not interchangeable. Version 4 is the one most people mean when they say "a UUID" with no qualifier: 122 bits are genuine random output from a cryptographic random number generator, and the remaining 6 bits are fixed to mark the id as version 4 under the RFC 4122 variant — that fixed nibble is why every v4 UUID this tool produces has a 4 in the same position (xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx) and a y that is always 8, 9, a or b. Nothing about a v4 id encodes when it was created, where it came from, or anything else about its origin — it is pure randomness with a version label stapled on, which is exactly the property that makes it safe to use as a security token or a public-facing identifier.

UUID v7 generator: time-ordered ids for database keys

Version 7 keeps the same 128-bit shape but spends its first 48 bits on a Unix millisecond timestamp instead of randomness, so two v7 ids generated further apart in time always sort in the order they were created — the remaining 74 non-fixed bits are still genuinely random, so two ids minted in the very same millisecond are ordered only by chance between themselves. This is worth having for one specific, increasingly common reason: a v4 id is 122 bits of pure randomness with zero relationship to when it was inserted, so as a table grows, every new row lands at a random position scattered across the whole index rather than appending near the end. On the B-tree index most relational databases build by default, that pattern causes constant page splits and poor cache locality — new rows should be cheap to insert, and with a v4 primary key on a large table, they increasingly aren't. A v7 id restores the append-mostly access pattern an auto-incrementing integer gives you, while still letting any client generate one independently with no round trip to a central counter and no realistic collision risk. The one thing you give up: the leading timestamp bits mean anyone who can see a v7 id can read off roughly when the row behind it was created, which a v4 id never reveals. If that leak is unacceptable for what the id identifies — a password-reset token being the clearest case — use v4 instead.

Bulk UUID generator: formats for pasting into code

Turn the count above 1 and every id fills the box below, one per line by default, with the same formatting options applied: uppercase or lowercase, with or without hyphens, and wrapped in { } for a value headed into SQL Server or the Windows registry. Turn on "Quoted list" when you're pasting straight into source code — it wraps each id in double quotes and joins them with a trailing comma and newline, the shape a string[] literal or a JSON array element already needs, so there's no follow-up find-and-replace before it compiles. "Copy all" copies exactly what the box shows, formatting and all.

UUID validator: check a pasted id and its version

Paste any string into the validator to find out two things: whether it is a syntactically valid UUID at all, and if so, which version and variant it claims to be. The check accepts the standard hyphenated form, a bare 32-digit hex string with no hyphens, and a brace-wrapped GUID — so a value copied straight out of a .env file, a JSON payload or SQL Server's UI validates the same way. "Valid" here means the shape is a well-formed 128-bit UUID; it cannot tell you whether the id was actually generated correctly upstream, the same way checking that a string is 16 digits doesn't confirm it's a real credit card number. The nil UUID and the "max" UUID (all fs) both validate as shape-correct with no version, which is expected — neither is a randomly generated id, so neither carries a version number to report.

Nil UUID

00000000-0000-0000-0000-000000000000 is the one UUID that is never generated randomly — it's a reserved value the specification sets aside to mean "no id" or "not set," the UUID equivalent of a null reference or an empty string used as a sentinel rather than a real value. It's included here, alongside its own copy button and the same formatting options as everything else, because the moment you need one you usually need it in the same format as the ids around it — braced for a SQL Server default, or bare for a config file.

Questions

What is a GUID?
A GUID (Globally Unique Identifier) is Microsoft's name for exactly the same thing a UUID is: a 128-bit value, almost always written as 32 hexadecimal digits in five groups separated by hyphens (8-4-4-4-12), such as 550e8400-e29b-41d4-a716-446655440000. The two terms are not two different formats — "UUID" comes from the Open Software Foundation's original specification and is the name used in most languages, databases and RFCs; "GUID" is the term Microsoft has used since early Windows and COM, and it shows up throughout .NET, SQL Server and the Windows registry, sometimes wrapped in curly braces like {550e8400-e29b-41d4-a716-446655440000}. If you generate an id here and call it a GUID in a C# project or a UUID in a Python one, you are describing the identical value both times.
Are UUIDs unique?
For all practical purposes, yes — that is the entire point of the format. A version 4 UUID has 122 bits of genuine randomness (the other 6 bits are fixed to mark it as a version-4, RFC 4122-variant id), which puts the space of possible ids at over 5 undecillion (5.3 x 10^36). To have even a 50% chance of one accidental collision, you would need to generate roughly 2.7 quintillion random v4 UUIDs — not 2.7 quintillion attempts to match one specific id, but that many ids generated in total before any two of them happen to match each other. No realistic system approaches that volume. The one thing that would break the guarantee is a broken random number generator producing biased or repeated output, which is exactly why this tool uses your browser's cryptographically secure `crypto.getRandomValues` (or `crypto.randomUUID()` directly) and never `Math.random()`, which is not designed to be unpredictable and is a real, documented source of UUID collisions when tools misuse it.
UUID v4 vs v7 — which one should I use?
Use v4 when the id itself must reveal nothing, including when it was created — a security token, a password-reset link, a public identifier in a URL. Use v7 when the id is a primary key in a database you control, especially at scale: v7 packs a millisecond timestamp into its first 48 bits, so ids generated later always sort after ids generated earlier. That matters because a v4 id is 122 bits of pure randomness with no relationship to insertion order, so as a database index grows, new rows land at random positions scattered across the whole index rather than appending at the end — on a B-tree index, the structure most relational databases use, that means constant index-page splits and poor cache locality, which gets slower as the table grows. A v7 id inserts in roughly ascending order, the same friendly access pattern an auto-incrementing integer gives you, while still being generated independently on any client with no coordination and no risk of collision. The trade-off is the one thing v7 gives up: the leading timestamp bits mean anyone who sees a v7 id can read off roughly when it was created, which a v4 id never reveals.
Can two UUIDs ever be the same?
In principle yes — nothing in mathematics forbids two independently generated random values from matching — but in practice the chance is close enough to zero that engineering treats it as impossible, the same way nobody designs around two independent computers happening to pick the identical winning lottery numbers. The realistic way two "UUIDs" end up equal is not a collision at all: it is the nil UUID (00000000-0000-0000-0000-000000000000), used deliberately as a placeholder for "no id" rather than generated randomly, or a bug where the same id is emitted twice because a cache, a retry or a copy-paste in code reused a value instead of generating a fresh one. If you are seeing a genuine duplicate from a real random UUID generator, the random number source is the thing to check first, not the odds.
Does this tool send my UUIDs to a server?
No. Every id above is generated by your own browser's `crypto` API and every check the validator runs happens in JavaScript running on this page — nothing is sent over the network, logged, or stored anywhere once you navigate away. That is a meaningful property specifically for a UUID generator: if you are about to use one of these ids as a real secret (a session token, an API key's identifier) or a real database key, an id that was ever transmitted to any server before you used it is an id someone else could theoretically have observed first. One generated entirely client-side never has that exposure.
What is the nil UUID, and when would I use it?
The nil UUID, 00000000-0000-0000-0000-000000000000, is a reserved value defined by the UUID specification to explicitly mean "no id" or "not set" — it is never produced by a random generator (the odds are the same as any other specific UUID, effectively zero) and is instead used deliberately, the same way a codebase might use a null pointer or an empty string as a sentinel. It is genuinely a valid UUID by shape — 32 hex digits in the standard grouping — which the validator below confirms, while correctly reporting that it carries no version, because "nil" is not one of the eight defined UUID versions.