This page generates version 4 UUIDs with the browser's cryptographic random generator. Choose how many you need, from 1 to 100, and optionally make them uppercase, wrap them in braces or remove the hyphens. Each one is created fresh in the tab; nothing is stored and nothing is sent anywhere.
A version 4 UUID is a 128-bit identifier where 122 bits are random and six bits are fixed to mark the version and the variant. That structure is what makes the result recognisable as a v4 UUID and what lets other software validate it. The page sets those bits correctly rather than generating 32 random hex digits and calling them a UUID.
What a version 4 UUID contains
The standard textual form is 36 characters: 32 hex digits in five groups of 8, 4, 4, 4 and 12, separated by hyphens. An example from a test run is 2f3da8bd-2953-4c62-aa4e-4c034fc07af5. The first character of the third group is always 4, because that group begins with the version nibble.
The first character of the fourth group is one of 8, 9, a or b, because the top two bits of that byte are the RFC 4122 variant. Every UUID on this page follows both rules, and a validator that checks them will accept the output.
Version 4 is the random variant. It carries no timestamp, no machine identifier and no sequence number, so it reveals nothing about where or when it was made. That is an advantage for identifiers in URLs and public records, and it also means the values cannot be sorted by creation time.
Count and formatting
The count field accepts a whole number from 1 to 100. A value below 1 becomes 1, a value above 100 becomes 100, and a decimal is rounded to the nearest whole number. The status line reports the count actually generated, and a warning names any adjustment, so a typed 0, 101 or 5.6 is never changed silently. Each UUID is independent; generating 100 is not a sequence derived from one seed.
Uppercase changes the hex letters to capitals. The value is the same; only the case differs. Many systems compare UUIDs case-insensitively, but a text comparison or a database column with a case-sensitive collation will treat the two forms as different, so match the convention of the place you are pasting.
Wrap in braces adds { and } around the value, a form common in Microsoft tooling and in some configuration files. Remove hyphens produces a 32-character string. That is not the standard textual representation, so a strict validator may reject it even though the underlying 128 bits are the same. The options can be combined; the test produced {82F9F7F68EFB491CABD74B2C3500077C} from all three at once.
A worked example
The default run generated 5 UUIDs and reported 610 random bits, which is 122 bits per identifier. All five were in the standard lowercase hyphenated form.
| Setting | Generated | Result |
|---|---|---|
| Default | 5 | 5 valid v4 UUIDs, 610 random bits |
| Count 1, uppercase, braces, no hyphens | 1 | {82F9F7F68EFB491CABD74B2C3500077C} |
| Count 0 | 1 | Clamped to 1 |
| Count 101 | 100 | Clamped to 100 |
A separate run generated 100 plain lowercase UUIDs. All 100 matched the standard v4 pattern, all 100 had a valid variant nibble, and all 100 were unique. That is the expected result for 100 draws from a 122-bit space; a collision is possible in principle but would be extraordinary at this scale.
The formatting run is worth checking closely. Removing the hyphens does not change the value, but it does change the length from 36 to 32 characters, and the braces add two more. A system that expects the canonical form will reject the braced or hyphen-free version even though the identifier is the same.
Uniqueness and safe use
Version 4 UUIDs are not secrets. The random bits come from a cryptographic source, which makes them hard to predict, but a UUID is designed to be an identifier and may be logged, indexed and shared. Do not use one as a password, an API key or a session token. Use a dedicated token generator with enough entropy for that purpose.
A collision needs two generated values to share all 122 random bits. At a billion UUIDs the chance is still tiny, which is why the format is used for database keys and request IDs. The usual risk is not the maths but the process: copying the same value into two records, or generating with a broken random source.
The page uses crypto.getRandomValues. If the browser does not expose it, the result explains that UUIDs cannot be generated rather than falling back to Math.random, which would be predictable. That failure is a safety feature, not an inconvenience.
When to use another UUID version
This page generates version 4 only. Version 1 combines a timestamp and a node identifier, which makes the values sortable but can leak the machine's address. Version 7 puts a Unix timestamp in the high bits, which gives sortable identifiers without the privacy problem, and it is a better choice for a new database key if your platform supports it.
Version 3 and version 5 are deterministic: the same namespace and name always produce the same UUID. They are for deriving stable identifiers, not for generating random ones. Version 4 is the right default when you just need a unique value and do not care about order.
For a set of test fixtures, generate once and keep the file; the values are random, so a second run will not reproduce them. The hash generator is the deterministic alternative when you need the same identifier from the same input every time, and the JSON formatter can check the array you build from the output.