UUID Generator — Manual

Back to overview: UUID Generator · Open the live tool: www.jpkc.com/tools/uuid/

This manual describes the UUID Generator in full: how the interface is laid out, what each of the six versions produces, how namespaces, bulk generation, the decoder, the output formats, and the NIL and Max UUIDs work, and where the random values come from. Labels are quoted exactly as they appear in the tool.

Interface layout

You operate the tool through five tabs at the top of the card — four for generating, one for reading UUIDs back:

v4 Random (active on load)
v7 Time-ordered
v6 / v1 Time-based (toggle between v6 and v1)
v5 / v3 Name-based (toggle between v5 and v3)
Decode (decoder for existing UUIDs)

Each generator tab has a short explanatory hint, the input fields it needs, its own Generate button, and a result field. To the right of the result field sit two stacked buttons: Copy (clipboard icon) and Download as .txt (down arrow). The result field is display-only — you can focus it with the keyboard and select text, but not edit it; on a freshly loaded page it is empty.

The card footer holds two things that apply to every tab: the Output format dropdown and the two special values NIL and Max, each with a copy button.

The Generate buttons are disabled in the delivered HTML and only become active once the tool's script has loaded.

Common workflow

The same basic flow applies to every version:

Pick a tab (version).
For v4, v7, and v6/v1: set Number of UUIDs; on v6/v1 also choose the Version. For v5/v3: choose the Namespace and Version and enter the Names (one per line).
Click the tab's button (Generate v4, Generate v7, Generate time-based, or Generate name-based).
Optionally switch the Output format in the footer — the display changes instantly, without regenerating.
Take the result with Copy or save it with Download as .txt.

Each tab keeps its own result: switch to another tab and back, and the last list you generated is still there.

The UUID versions in detail

Version 4: random (v4 Random)

Generates purely random UUIDs (RFC 9562, Version 4). The tab hint reads "122 random bits from the browser's cryptographic generator. The usual choice when the ID does not need to sort." There is no time or device information in the UUID; apart from the fixed version and variant bits, all 122 bits are random.

The random values come from the browser's cryptographically secure generator: where available, the tool uses the native crypto.randomUUID(), otherwise it fills 16 bytes via crypto.getRandomValues and sets the version/variant bits itself. Either way the source is a CSPRNG, not Math.random.

Input: Number of UUIDs; button: Generate v4.

Version 7: time-ordered (v7 Time-ordered)

Generates time-ordered UUIDs (RFC 9562, Version 7). The first 48 bits are a Unix timestamp in milliseconds (big-endian); the remaining 74 freely usable bits (12 bits rand_a, 62 bits rand_b) come from the CSPRNG. The tab hint: "Unix milliseconds + random (RFC 9562). Monotonic: UUIDs from the same millisecond still sort in creation order — good primary keys for databases."

The tool generates v7 monotonically, following the "monotonic random" method from RFC 9562 (section 6.2):

In a new millisecond it draws a fresh 74-bit random value with its top bit cleared — leaving plenty of headroom for increments.
Within the same millisecond it adds a random step (1 to roughly 2³¹) to that value. The sequence stays strictly increasing while remaining hard to guess.
If the value overflows, the tool advances the millisecond logically by one. If the system clock jumps backwards, it keeps the last timestamp rather than going back in time.

The upshot: even 10,000 v7 UUIDs generated in one go come out in exact creation order, and they sort correctly both as text in canonical form and as bytes (the Base64 forms do not). That makes them good database keys: new rows land at the end of the index instead of scattering it the way random v4 values do. Monotonicity holds within one page load; between two browser tabs or two machines, only the milliseconds provide the order.

Input: Number of UUIDs; button: Generate v7.

Version 6 and version 1: time-based (v6 / v1 Time-based)

Generates time-based UUIDs with a Gregorian timestamp. The tab hint: "Gregorian timestamp (100 ns), clock sequence and a random node (multicast bit set — no MAC address). v6 sorts by time; v1 only for systems that require it."

The Version toggle offers:

v6 (default) — the same 60-bit timestamp as v1, but stored in big-endian order: the UUIDs sort by time like v7 while keeping the v1 fields.
v1 — the classic field order (low time bits first); only worthwhile when an existing system demands v1.

Common to both:

Timestamp: 100-nanosecond intervals since 15 October 1582, derived from the browser clock. When several UUIDs fall into the same tick (or the clock jumps back), the tool simply counts the timestamp up by one. v1 and v6 share this counter, so values stay unique and ascending; there is no abort for generating too many UUIDs per time unit.
Clock sequence: 14 bits, chosen at random when the page loads.
Node: 48 bits, chosen at random when the page loads, with the multicast bit set (RFC 9562, section 6.10). The tool reads no MAC address, so no hardware identifier is revealed. Within one page load, all v1/v6 UUIDs carry the same node and clock sequence; reload the page and both are new.

Inputs: Number of UUIDs and Version; button: Generate time-based.

Version 5 and version 3: name-based (v5 / v3 Name-based)

Generates name-based, deterministic UUIDs (RFC 9562, Versions 5 and 3). The decisive difference from the other versions: the same namespace and the same name always produce the same UUID. The tab hint: "Same namespace + name → always the same UUID. v5 hashes with SHA-1, v3 with MD5 (only for compatibility). The name is used exactly as entered, spaces included."

The Version toggle selects the hash:

v5 (SHA-1) (default) — the recommended variant; the hash runs through the browser's Web Crypto API (asynchronously).
v3 (MD5) — only for compatibility with systems that expect v3. Because Web Crypto offers no MD5, the tool ships its own MD5 implementation for it.

Technically, the tool concatenates the 16 bytes of the namespace with the UTF-8 encoded name, hashes the result, and takes the first 16 bytes as the UUID, with the version bits (5 or 3) and variant bits set.

The inputs:

Namespace and, where needed, Custom namespace UUID — see Namespaces for v5 and v3.
Version — v5 (SHA-1) or v3 (MD5).
Names — one per line — the strings to derive from (placeholder example.com).

One name per line: every line yields exactly one UUID, in the same order — line 3 of the input belongs to line 3 of the output. There is no count selector here; the number of lines decides the quantity. Windows line breaks are normalized, and a single trailing line break is ignored. A blank line between two names, however, counts as an empty name and produces a UUID too.

Names exactly as entered: the tool trims nothing. A space or tab at the start or end belongs to the name and gives a completely different UUID. So that this doesn't slip past you, a yellow hint appears live below the field, such as "Line 2 starts or ends with a space — it is part of the name and changes the UUID." (up to ten line numbers, then "…").

If the names field is empty, the tool reports "Please enter a name.".

Namespaces for v5 and v3

The namespace defines the "context" in which the name is interpreted — the same name in two different namespaces yields two different UUIDs.

Predefined namespaces

The Namespace dropdown offers the four standard namespaces defined in RFC 9562 (Appendix A); each entry shows the start of its UUID, for example DNS (6ba7b810-…):

DNS (6ba7b810-9dad-11d1-80b4-00c04fd430c8, default) — for domain names, e.g. example.com.
URL (6ba7b811-9dad-11d1-80b4-00c04fd430c8) — for full URLs.
OID (6ba7b812-9dad-11d1-80b4-00c04fd430c8) — for object identifiers.
X.500 (6ba7b814-9dad-11d1-80b4-00c04fd430c8) — for X.500 distinguished names.

Custom namespace (Custom UUID)

Pick Custom UUID in the dropdown and the Custom namespace UUID field becomes active and takes the focus. Enter your own namespace UUID there — in any spelling the decoder understands: with or without hyphens, upper or lower case, in curly braces, with a urn:uuid: prefix, or as Base64/Base64url. If the input cannot be read in any of these spellings, the field turns red while you type; click Generate name-based anyway and the tool reports "Invalid namespace UUID.". This lets you build a project-specific namespace hierarchy and derive v5 or v3 UUIDs from it reproducibly.

Count and bulk generation

For v4, v7, and v6/v1 there is the Number of UUIDs number field — each tab has its own. The allowed range is 1 to 10,000; the field's suggestion list offers 1, 10, 100, 1000, and 10000, but you can type any value in between. Empty or invalid input is treated as 1. Click the tab's Generate button with a value above 10,000 and the tool resets the field to 10,000, generates 10,000 UUIDs, and reports "At most 10,000 at once.". The number in the message follows your browser's language — a German-language browser shows "10.000".

When you generate several, the tool lists them one per line in the result field — convenient for copying as a block or downloading. For v5/v3 the number of name lines decides the quantity (see above).

NIL and Max UUID

The card footer permanently shows the two special values from RFC 9562:

NIL: 00000000-0000-0000-0000-000000000000 — all 128 bits zero. It serves as a placeholder or null value where a UUID is expected but no real one is set.
Max: ffffffff-ffff-ffff-ffff-ffffffffffff — all 128 bits one. It works as an upper bound, for example in range queries, or as a sentinel value.

A small copy button beside each puts the value on the clipboard — in the currently selected Output format: with the format set to {Braces} (Microsoft), you copy {00000000-0000-0000-0000-000000000000}.

Copying and downloading

Next to each result field sit two buttons:

Copy (clipboard icon) puts the entire displayed content on the clipboard. If the field is still empty, you see "Nothing to copy — generate some UUIDs first.".
Download as .txt (down arrow) saves the content as the text file uuids.txt — UTF-8, one UUID per line, with a trailing line break. Without a result, the tool reports "Nothing to download — generate some UUIDs first.".

Both buttons take the text as displayed — that is, in the selected output format.

Output format

The Output format dropdown in the card footer determines how all generated UUIDs are displayed, copied, and downloaded. Internally the tool keeps every UUID in canonical form, so switching formats re-renders all four result fields instantly without generating new UUIDs. The browser remembers your choice (localStorage) for the next visit.

The seven formats, using f47ac10b-58cc-4372-a567-0e02b2c3d479 as the example:

Option in the tool	Output
`Standard (lower case)`	`f47ac10b-58cc-4372-a567-0e02b2c3d479`
`Upper case`	`F47AC10B-58CC-4372-A567-0E02B2C3D479`
`Without hyphens`	`f47ac10b58cc4372a5670e02b2c3d479`
`{Braces} (Microsoft)`	`{f47ac10b-58cc-4372-a567-0e02b2c3d479}`
`urn:uuid: (RFC 9562)`	`urn:uuid:f47ac10b-58cc-4372-a567-0e02b2c3d479`
`Base64`	`9HrBC1jMQ3KlZw4CssPUeQ==`
`Base64url (no padding)`	`9HrBC1jMQ3KlZw4CssPUeQ`

Standard is the default. Base64 and Base64url encode the UUID's 16 raw bytes (22 characters, padded with == for Base64); Base64url replaces + and / with - and _ and drops the padding — handy for URLs and file names. The Decode tab does not follow the output format; it always shows the canonical form.

Decoder (Decode)

The Decode tab reads existing UUIDs. Paste them into the UUIDs field, one per line (the placeholder is a v7 UUID from RFC 9562). Decoding runs live as you type — there is no button. Blank lines are skipped, and at most the first 200 lines are evaluated.

Accepted spellings: with or without hyphens, upper or lower case, in curly braces, with a urn:uuid: prefix, plus Base64 and Base64url (22 characters, with optional == for Base64). Spaces at the start or end of a line do no harm.

Each line gets a card whose header shows the UUID in canonical form. Below it, depending on the content:

Version — number and meaning, e.g. 7 — time-ordered (Unix ms). The labels: 1 time-based (Gregorian), 2 DCE security, 3 name-based (MD5), 4 random, 5 name-based (SHA-1), 6 time-ordered (Gregorian), 7 time-ordered (Unix ms), 8 custom.
Variant — RFC 9562 (10xx) for standard UUIDs; the decoder also recognizes NCS (reserved, 0xxx), Microsoft (110x), and Future (111x). The version meaning and time details are only shown for the RFC variant.
Time (UTC) and Time (local) — for v1, v6, and v7: the creation time as an ISO 8601 timestamp in UTC and written out in your browser's time zone and language.
For v1 and v6 additionally Timestamp (100 ns since 1582-10-15) (raw value), Clock sequence, and Node — the latter with "(random — multicast bit set)" for a random node or "(MAC address)" when the multicast bit is not set.
For v7 additionally Random / counter (74 bit) as a hex value.
For v3 and v5 the note "Hash of namespace + name — the name cannot be recovered" — the name cannot be recovered from the UUID.
For v4 the entry Random bits 122.

The special values get their own Type row: "NIL UUID (all zeros)" or "Max UUID (all ones, RFC 9562)". An invalid line gets Valid "No — Not a UUID: …" followed by the original input. One exception: a line of exactly 22 characters from the Base64 alphabet — such as a UUID truncated to 22 characters — is read as Base64, and the decoder shows a card with a seemingly valid but meaningless UUID (often with an unusual version and variant).

Random source and security

The random versions v4, v7, and v6/v1 draw their random bits from the browser's cryptographically secure random generator — crypto.getRandomValues, and for v4 directly crypto.randomUUID() where available. This matters for security: unlike Math.random, this source is not predictable, so v4 UUIDs and the random part of v7 cannot be guessed. With v6/v1 the node and clock sequence are random, but the timestamp is not — within one page load these UUIDs are sequential. v5 and v3 are not random at all but computed deterministically via SHA-1 or MD5. For v5 the tool uses the Web Crypto API, which requires a secure context (HTTPS).

Operating limits and privacy

Client-side: generating and decoding happen in the browser. There is no server call and no transmission of names, namespaces, or results.
Storage: only the selected Output format is kept in your browser's localStorage; generated UUIDs, names, and decoder input are not stored.
Secure context: the Web Crypto API used for v5 requires HTTPS (or localhost).
Quantities: 1 to 10,000 UUIDs per run (v4, v7, v6/v1); for v5/v3 one UUID per name line; the decoder evaluates up to 200 lines.
Formats: seven output formats, applied to the display, copying, downloading, and the NIL/Max buttons.
Versions: v4, v7, v6, v1, v5, v3, plus the NIL and Max UUID. The decoder additionally recognizes v2 (DCE security) and v8 (custom) but does not generate them.

For the introduction and version recommendation see the overview page. Concrete walkthroughs are in the examples, strategy and pitfalls in the tips & tricks. You can try everything directly in the tool.