ToolsHub4u

Generate random version 4 UUIDs

Generate random version 4 UUIDs with the browser's cryptographic source. Choose a count up to 100 and an optional uppercase, braced or hyphen-free format.

  • Cryptographic randomness
  • 1 to 100 at once
  • Runs locally
Ready Developer & Utility
1Enter
2Adjust
3Copy result

UUID Generator

1

How many and how formatted

Between 1 and 100. Each UUID is independent.

Formatting

Braces are common in Microsoft tooling. Removing hyphens produces a 32-character identifier, which is not the standard textual form.

No data yet Ready
2

UUIDs

Generated 5 version 4 UUIDs in this tab.

First UUID

68c652f7-48da-49aa-b634-e2c1f7a01419

All 5 UUIDs

  • Version and variant bits are setByte 6 carries the version 4 marker and byte 8 carries the RFC 4122 variant. The other 122 bits come from the browser's cryptographic random generator.
  • These are created fresh each timeReloading or pressing Generate again produces a new list. Nothing is stored, so copy the IDs you need before leaving the page.
Generated
5
Version
4 (random)
Random bits
610

Version 4 UUIDs are random, so a collision is possible in principle but negligible at ordinary volumes. Do not use them as secrets or passwords.

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.

Generation results for three settings
SettingGeneratedResult
Default55 valid v4 UUIDs, 610 random bits
Count 1, uppercase, braces, no hyphens1{82F9F7F68EFB491CABD74B2C3500077C}
Count 01Clamped to 1
Count 101100Clamped 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.

Keep the canonical form for storageStore the lowercase hyphenated value and format it only at the edge, when a particular tool demands braces or capitals.

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.

Questions

Common questions

Short answers about this tool and its limits.

Are these really random?

Yes. The bits come from crypto.getRandomValues, a cryptographic random source, not from Math.random. If that API is unavailable the page refuses to generate rather than falling back to a weaker source.

Can I use a UUID as a password or API key?

No. A UUID is an identifier, not a secret, and it is often logged or exposed in URLs. Use a dedicated token generator with enough entropy for credentials.

How many can I generate at once?

Between 1 and 100. A lower value is raised to 1, a higher one is capped at 100, and a decimal is rounded to the nearest whole number. The status line reports the count actually generated, and a warning names the adjustment. Run the page again for another batch.

Why is my UUID 32 characters instead of 36?

Because Remove hyphens was on. The underlying value is the same, but the 32-character form is not the standard textual representation and a strict validator may reject it.

Are braces part of a UUID?

No. Braces are a presentation choice common in Microsoft tooling. The identifier is the 36-character hyphenated value; the braces are added around it and can be removed without changing it.

Can two generated UUIDs collide?

In principle yes, because 122 bits is a finite space. In practice the chance is negligible at ordinary volumes. The test of 100 values produced no duplicates, which is expected rather than proof of uniqueness.

Does it generate version 1 or version 7?

No, version 4 only. Version 7 is a better choice for sortable database keys if your platform supports it, and version 5 is the deterministic option. Use a different tool for those.

Are the UUIDs stored anywhere?

No. They are created in the tab and there is no account, history or server copy. Pressing Generate again replaces the list, so copy or download the values you need before leaving the page.