UUID Generator

Metric	Value	Copy
{{ r.label }}	{{ r.value }}
No data yet. Generate a UUID.

Universally unique identifiers are 128 bit labels that distinguish records and messages without coordination. They support consistent keys across systems and a deterministic identifier generator helps repeat the same mapping when you need it.

You choose the family that fits your case and then read the result in a compact summary. Time based values can reveal their recorded moment so ordering and indexing remain practical in logs and pipelines.

Name based values repeat with the same name and namespace so the same input always maps to the same output. Random values are independent between runs so you can issue tokens that avoid linking across events.

Provide a name with a namespace for stable mapping, or choose random for independence, or choose time based when ordering helps. The result appears with its version and variant plus clean formats that downstream tools expect.

Keep names free of secrets and avoid exposing private data in shared contexts. When the result matters for audit, store the canonical form and add braces or casing only when a consuming system requires it.

Technical Details:

This generator works with the Universally Unique Identifier (UUID) format defined in RFC 4122. A UUID is 128 bits arranged in five groups, and it carries a version and variant that indicate how it was produced.

Two name‑based families compute a hash of a namespace value and a name string. Version 3 uses MD5 and version 5 uses SHA‑1; identical inputs always yield the same output.

The time‑based family encodes a 60‑bit timestamp in 100 ns intervals since 1582‑10‑15, plus a 14‑bit clock sequence and a 48‑bit node identifier. The random family draws 122 random bits and then sets version and variant according to the standard.

Version 1 values are decoded here into UTC and local wall‑clock time, along with the clock sequence and node bytes. The variant is reported using the standard classes: NCS, RFC 4122, Microsoft, or Reserved.

\begin{matrix} time & = & (time_hi_and_version \land 0x0FFF) ≪ 48 + time_mid ≪ 32 + time_low \\ t_{unix,ms} & = & ⌊ \frac{time}{10^{4}} ⌋ - 12219292800000 \end{matrix}

Symbols and units
Symbol	Meaning	Unit/Datatype	Source
`time_low`	Low 32 bits of the timestamp	hex 32‑bit	Derived from bytes
`time_mid`	Middle 16 bits of the timestamp	hex 16‑bit	Derived from bytes
`time_hi_and_version`	High 12 bits of time plus version nibble	hex 16‑bit	Derived from bytes
`time`	UUID v1 time since 1582‑10‑15	100 ns ticks	Computation
`t_unix,ms`	Unix epoch time	ms	Computation
`clockseq`	Clock sequence for v1 sequencing	14‑bit integer	Derived from bytes
`node`	Node identifier bytes	6 bytes	Derived from bytes

Worked example (conceptual): Parse time_low, time_mid, and time_hi_and_version, mask the version bits, combine into time, divide by 10⁴ to get milliseconds, subtract 12 219 292 800 000, then format as ISO 8601 UTC. The same value is also shown in your local time for readability.

Variant interpretation
Variant class	Top bits (octet 9)	Meaning
NCS	`0b0xxx xxxx`	Pre‑standard
RFC 4122	`0b10xx xxxx`	Standard UUID
Microsoft	`0b110x xxxx`	Legacy Microsoft format
Reserved	`0b111x xxxx`	Future use

For v3 or v5, resolve the namespace as DNS, URL, OID, X500, or a provided UUID.
Normalize the namespace to canonical form if 32 hex digits are supplied.
Concatenate namespace bytes with the UTF‑8 bytes of the name.
Hash with MD5 (v3) or SHA‑1 (v5) and take 16 octets.
Set the version nibble and variant bits; format as canonical text.

Validation rules encoded in the UI
Field	Type	Min	Max	Step/Pattern	Error Text	Placeholder
Version	Enum	—	—	v1, v3, v4, v5	—	Version selector
Name (v3/v5)	String	1	—	trimmed	“Enter a name string for v3/v5 UUID generation.”	example.com
Namespace (v3/v5)	String	—	—	`DNS\|URL\|OID\|X500` or `[0‑9A‑F]{32}` or `[0‑9A‑F‑]{36}` (case‑insensitive)	“Enter a valid namespace: DNS, URL, OID, X500, or a RFC4122 UUID.”	DNS / URL / UUID
Formatting	Booleans	—	—	uppercase, remove dashes, include braces	—	—

I/O formats
Input	Accepted Families	Output	Encoding/Precision	Rounding
Version choice	v1, v3, v4, v5	UUID text	canonical, uppercase, no‑dash, braces, URN	n/a
Name + Namespace	DNS, URL, OID, X500, UUID	Deterministic UUID	lowercase canonical by default	n/a
v1 decode	UUID text	UTC and local time, clockseq, node	ISO 8601 UTC, locale‑aware local	ms (100 ns base)

Units, precision & rounding: Times are shown in ISO 8601 UTC and as a locale‑formatted local time. v1 time is derived from 100 ns ticks; displayed values are in milliseconds without special tie‑breaking.

Randomness & reproducibility: v3/v5 are deterministic for a given name and namespace. v4 draws new randomness each run. v1 uses the current time with a clock sequence and node bytes.

Time & calendrics: Local time uses the device locale and timezone. Leap seconds are not represented; ISO 8601 date‑time strings reflect wall‑clock time.

Networking & storage: Processing is browser‑based; downloads are assembled locally. Clipboard copy uses the secure clipboard API when available with a fallback strategy for older environments.

Diagnostics & determinism: Identical inputs produce identical outputs for v3/v5. The UI highlights the active variant and version and emits CSV and JSON summaries for inspection.

Security considerations: Do not treat a UUID as an access control secret. v1 may reveal properties of the generating host; avoid sharing sensitive values publicly.

Heads‑up Namespace regex accepting 36‑character input does not enforce group boundaries; non‑canonical dash placement passes as‑is.
Names are trimmed; internal whitespace is preserved.
Clipboard operations may be blocked in insecure contexts.
History keeps the most recent 20 entries only.
Auto‑generate is debounced by about 40 ms when settings change.
Uppercase, dash removal, and braces affect only the formatted display.
URN output uses the canonical form: urn:uuid:<uuid>.
JSON and CSV are generated in memory; very large histories can impact memory.

Edge cases & error sources

Unicode names are accepted; no normalization is applied.
Leading and trailing spaces are trimmed from names and namespaces.
Invalid namespaces for v3/v5 block generation until corrected.
Locale settings can change the appearance of the local time string.
Very old environments may reduce randomness quality for v4.
System clock skew affects v1 ordering across machines.
Copy fallback may fail if selection APIs are unavailable.
Downloaded files may be quarantined by strict security policies.
JSON syntax highlighting is cosmetic; content remains plain JSON.
Pastes into systems with strict validators may require canonical form.

Privacy & compliance: No data is transmitted or stored server‑side. Avoid embedding personal or confidential information in names or exported artifacts.

Step‑by‑Step Guide

UUID creation and inspection follow a simple sequence to produce a clean identifier and companion details.

Select a version. Use time‑based for ordering, name‑based for stable mapping, or random for unlinkable values.
For v3/v5, enter a Name and a Namespace such as DNS or a UUID string.
Optionally adjust presentation with uppercase, dash removal, or braces.
Review version, variant, URN, and for v1 also the UTC and local times.
Copy the needed form or download JSON/CSV for logs.

Invalid or empty namespace for v3/v5 prevents generation until corrected.

Example: Choose v5, set Namespace to DNS, Name to example.com, then copy the canonical value for repeatable use across systems.

Prefer the canonical lowercase form unless a consumer requires otherwise.
Record the URN when a prefix is needed in text‑based registries.
For audit trails, log version and variant alongside the identifier.

FAQ

Is my data stored?

No. All processing happens on your device and no data is sent to a server. Clipboard and downloads are initiated locally.

Avoid placing secrets in names or exported files.

How accurate is the v1 time?

It reflects 100 ns tick math per RFC 4122 but displays in milliseconds. Local time uses your device locale and timezone.

Which namespaces are accepted?

DNS, URL, OID, X500, or a UUID string. A 32‑hex input is canonicalized; a 36‑character hex‑with‑dashes input is accepted as entered.

Can I use it offline?

Once loaded, generation and inspection run locally without network access. Exports and copy also work without a connection.

What does a “Reserved” variant mean?

It indicates bit patterns set aside for future definitions. Treat such values as unsupported unless your system specifies handling.

How do I validate a UUID string?

Use the canonical 8‑4‑4‑4‑12 hex grouping or supply 32 hex digits to be canonicalized. Check version and variant to confirm expectations.

Are name strings case‑sensitive?

They are used exactly as entered after trimming; no normalization is applied. Changing case changes the result for v3/v5.

Is there a cost or license?

Identifiers are created locally on your device. No purchase or subscription is required for generation and inspection.

Troubleshooting

“Copy” does nothing → enable clipboard permissions or use the JSON/CSV download.
v3/v5 disabled → provide a valid namespace and a non‑empty name.
Unexpected local time → check your device timezone and locale settings.
Consumer rejects value → send the canonical form without braces or uppercase.
Download blocked → allow downloads or use copy and paste as a fallback.
Variant is “Reserved” → confirm whether your system supports that class.

Blocking: An invalid namespace prevents name‑based generation. Enter DNS, URL, OID, X500, or a valid UUID.

Advanced Tips

Tip Prefer v5 over v3 when you need a longer‑lived hash function.

Tip Keep an internal map of names to values to prevent accidental renaming.

Tip Store the URN form when a prefix simplifies downstream parsing.

Tip Use v1 only when ordering is valuable and node metadata is acceptable.

Tip Log version and variant alongside the value for quicker audits.

Tip Test consumers with both canonical and urn forms to confirm expectations.

Glossary

UUID: Universally Unique Identifier, a 128‑bit identifier format.
Version: Method used to construct the identifier, e.g., time‑based or name‑based.
Variant: Bit pattern class that defines the layout rules.
Namespace: Fixed context value combined with a name for v3/v5.
Clock sequence: v1 field that helps maintain monotonicity across ticks.
Node: Six‑byte identifier used by v1, often MAC‑like or locally administered.

UUID Generator

Introduction:

Technical Details:

Edge cases & error sources

Step‑by‑Step Guide

FAQ

Troubleshooting

Advanced Tips

Glossary