UUID Generator

Introduction

The Toollect UUID Generator is a browser-based tool that produces Universally Unique Identifiers (UUIDs, also known as GUIDs) across all eight standard versions — v1 through v8. Whether you need random identifiers for web forms, time-ordered keys for database records, deterministic namespaced IDs for distributed systems, or custom format UUIDs for legacy integration, this tool covers the full spectrum without requiring any software installation or server-side processing.

UUIDs are one of the most widely adopted identifier standards in software engineering, used everywhere from database primary keys and API resource identifiers to distributed tracing and session tokens. The Toollect UUID Generator consolidates all UUID versions into a single interface, letting you pick the right variant for your use case and generate it instantly with a single click.

All generation runs entirely within your browser using the Web Crypto API. No data is transmitted over the network, no cookies are set, and no identifiers are logged. The tool works offline after the initial page load and across all modern browsers and devices.

Use Cases

Different UUID versions serve different architectural needs. Choosing the right version depends on your requirements for ordering, determinism, privacy, and system coordination.

Database Primary Keys

UUIDs eliminate the need for a central sequence when generating primary keys across distributed database instances. UUID v4 is the simplest drop-in choice, but UUID v6 and v7 offer time-sorted ordering that significantly reduces B-tree index fragmentation in databases like PostgreSQL and MySQL. For systems that need both global uniqueness and fast write performance, v7 has become the modern recommended choice.

Distributed System Identifiers

Microservices and distributed systems often generate identifiers independently on different nodes. UUID v1 includes a node identifier (derived from MAC address) and clock sequence, making each generating node's IDs inherently unique without coordination. UUID v4 and v7 are also popular for this scenario due to their simplicity.

Deterministic Name-Based IDs

When the same input should always produce the same UUID — for example, generating a stable identifier from a user email, a resource URL, or a namespace-qualified name — UUID v3 (MD5-based) and v5 (SHA-1-based) provide determinism. This is useful for content-addressable storage, entity identity in event sourcing, and migrating legacy data without changing identifiers.

API Resource Identifiers

Exposing auto-incrementing integers in API URLs leaks information about resource quantity and ordering. UUIDs provide opaque identifiers that reveal nothing about system internals. UUID v4 is the most common choice for REST API resource paths. The tool's uppercase and no-dash formatting options make it easy to adapt UUIDs to different URL and formatting conventions.

Custom and Legacy Systems

UUID v2 (DCE Security) adds local user and group identifiers for operating system-level security contexts. UUID v8 allows custom field layouts for systems that need to embed specific data bits while maintaining the standard UUID format. These versions are niche but valuable for specialized integration scenarios.

How It Works

The UUID Generator operates entirely client-side. When you select a version and click generate, the tool invokes the appropriate algorithm using JavaScript and the browser's Web Crypto API.

For random-based UUIDs (v4), the tool calls crypto.getRandomValues() to produce cryptographically secure random bytes, then formats them into the standard UUID layout with the correct version and variant bits. For time-based UUIDs (v1, v2, v6, v7), the tool reads the current timestamp from the system clock and combines it with random clock sequence and node bytes. For name-based UUIDs (v3, v5), the tool hashes a namespace and name together using MD5 or SHA-1 via the SubtleCrypto API, then extracts 128 bits into the standard UUID format.

UUID Format

A UUID is a 128-bit value displayed as a 36-character string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, where each x is a hexadecimal digit. The 128 bits are structured into fields:

The version nibble (bits 48-51, the most significant nibble of the third group) identifies which algorithm produced the UUID: 0001 (v1), 0010 (v2), 0011 (v3), 0100 (v4), 0101 (v5), 0110 (v6), 0111 (v7), 1000 (v8). This is the 4 you see in a standard UUID v4 like 550e8400-e29b-41d4-a716-446655440000.

The variant bits (bits 64-65, the two most significant bits of the fourth group's first byte) indicate the UUID variant. RFC 9562 specifies variant 10xxxxxx (bits 64-65 = 10), meaning the first character of the fourth group is always 8, 9, a, or b.

Binary Layout Example

The 128-bit structure of a UUID is best understood visually. Taking a concrete UUID v4 550e8400-e29b-41d4-a716-446655440000, here is how the bits map to each group and field:

Group:      1          2          3          4          5
Hex:     550e8400    e29b       41d4       a716       446655440000
Binary:  [32 bits]   [16 bits]   [16 bits]  [16 bits]  [48 bits]

Version nibble (group 3, high nibble):
  550e8400-e29b-4  1d4-a716-446655440000
                  ^
                  version = 0100 (v4)

Variant bits (group 4, high byte):
  550e8400-e29b-41d4-  a  716-446655440000
                       ^
                       variant = 10xxxxxx

Full binary breakdown of groups 3-4:

  group 3 (16 bits)      group 4 start (8 bits)
  0100 0001 1101 0100    1010 0111
  └─┘                    └─┘
  ver=0100 (v4)          variant | clock_seq_hi
                         10

For UUID v7, the first 48 bits encode the Unix millisecond timestamp:

  018f3a6e-1a2b-  7  bcd-8a1b-2c3d4e5f6789
                  ^
                  version = 0111 (v7)

  groups 1-2: 48-bit Unix ms timestamp
  0000 0001 1000 1111 0011 1010 0110 1110 0001 1010 0010 1011
  group 3 high nibble:
  0111  = version 7

The high byte of group 4 (a in the example above) contains the variant bits. Since the variant is 10, this byte always falls in the range 1000 0000 (0x80) through 1011 1111 (0xBF), which in hex corresponds to 8, 9, a, or b as the first character of the fourth group.

UUID Versions Explained

The following table summarizes the eight standard UUID versions at a glance:

UUID v1 — Time-Based

UUID v1 combines a 60-bit timestamp (100-nanosecond intervals since October 15, 1582), a 14-bit clock sequence (for clock rollback detection), and a 48-bit node identifier (traditionally derived from the MAC address). This gives each generating node a unique identifier space without coordination.

The timestamp is laid out with the low, middle, and high parts across the first three groups of the UUID. This non-sequential layout means that v1 UUIDs are time-sortable but not in a database-friendly monotonic order — v6 and v7 address this.

UUID v2 — DCE Security

UUID v2 extends the v1 timestamp and clock sequence layout but replaces the 48-bit node field with a 32-bit POSIX user ID (UID) or group ID (GID) and a 6-bit local domain identifier. The remaining 10 bits of the node field and 2 bits of the clock sequence are repurposed for the local domain and its structure:

UUID v2 is specified in the DCE 1.1: Remote Procedure Call standard, not in the core RFC 9562 UUID specification. It is rarely used outside of legacy DCE environments, and most modern UUID generators either omit it or include it only for completeness. If you are building a new system, use v4, v7, or v5 instead.

UUID v3 — MD5 Name-Based

UUID v3 generates a deterministic UUID from a namespace UUID and a name string. The process concatenates the namespace and name bytes, computes an MD5 hash, and takes the first 128 bits as the UUID. The same namespace and name always produce the same v3 UUID, making it suitable for content addressing and stable identifiers.

See the UUID v3 vs v5 section below for a comparison of the two name-based versions.

UUID v4 — Random

UUID v4 uses 122 randomly generated bits plus 6 fixed bits (4 for the version nibble, 2 for the variant). This is the most widely used UUID version, supported directly by most programming language standard libraries. The Toollect UUID Generator uses crypto.getRandomValues() to ensure cryptographically secure randomness, making the output suitable for security-sensitive contexts like session tokens.

The probability of a collision across one billion generated v4 UUIDs is approximately 1 in 5.3 × 10²¹ — negligible for all practical purposes.

UUID v5 — SHA-1 Name-Based

UUID v5 is the counterpart to v3, using SHA-1 instead of MD5 for the underlying hash. It produces the same determinism guarantees (same namespace + name = same UUID) with a more collision-resistant hashing algorithm. For new systems that need name-based UUIDs, RFC 9562 recommends v5 over v3.

See the UUID v3 vs v5 section below for the detailed comparison.

UUID v6 — Reordered Time-Based

UUID v6 restructures the v1 timestamp to place the most significant time bits first. This makes v6 UUIDs monotonically increasing when sorted lexicographically, unlike v1 where the timestamp is split across non-adjacent fields. UUID v6 is a modern replacement for v1 in environments where time-ordered database indexes or sorted storage matter.

UUID v7 — Unix Timestamp + Random

UUID v7 uses a 48-bit Unix millisecond timestamp followed by 74 random bits. The timestamp occupies the most significant bits, making v7 UUIDs sortable by creation time — ideal for database primary keys where B-tree index performance is a concern. UUID v7 is simpler than v1 or v6 because it does not require MAC addresses, clock sequences, or 100-ns epoch conversions.

For new systems that need time-ordered UUIDs, v7 is generally the best choice: it provides millisecond precision ordering, wide randomness, and straightforward implementation.

UUID v8 — Custom

UUID v8 reserves the version-8 identifier space for experimental or proprietary UUID formats. The only fixed bits are the 4-bit version nibble (1000) in bits 48-51 and the 2-bit variant (10) in bits 64-65 — the remaining 122 bits are free for any custom field layout.

Common uses for UUID v8 include embedding a company-specific prefix, combining a truncated timestamp with a sequence counter, or encoding a legacy identifier into UUID format while maintaining standard format compatibility. For example, a system might allocate the first 32 bits as a tenant ID, the next 32 bits as a millisecond timestamp, and the remaining 64 bits as a random suffix — all within a format that any standard UUID parser can read without modification.

The v8 format is not registered with IANA and has no interoperability guarantees across systems. It is a private-use space for cases where standard UUID versions do not fit the required data layout.

UUID v3 vs v5

Both UUID v3 and v5 generate deterministic identifiers from a namespace UUID and a name, but they differ in their hashing algorithm:

The Toollect UUID Generator includes four predefined standard namespaces defined by RFC 9562: DNS (6ba7b810-9dad-11d1-80b4-00c04fd430c8), URL (6ba7b811-9dad-11d1-80b4-00c04fd430c8), OID (6ba7b812-9dad-11d1-80b4-00c04fd430c8), and X.500 (6ba7b814-9dad-11d1-80b4-00c04fd430c8). You can also supply a custom namespace in standard UUID format for use with non-standard namespaces.

Usage

Using the Toollect UUID Generator requires no setup or registration. The interface is split into two panels — one for UUID v1/v2/v4/v6/v7/v8 (instant generation) and one for UUID v3/v5 (name-based generation).

Block 1 — Standard UUIDs (v1, v2, v4, v6, v7, v8)

1. Select the UUID version from the dropdown menu. The default is v4.
2. Click Generate or press Enter. A new UUID appears in the output field instantly.
3. Toggle formatting options as needed:
   • Uppercase: Converts the output to uppercase hex digits.
   • No Dashes: Removes the hyphens, producing a compact 32-character string.
4. Copy the result by clicking the Copy button next to the output field.

The version dropdown switch triggers automatic regeneration, so changing from v4 to v7 immediately produces a new identifier.

Block 2 — Name-Based UUIDs (v3, v5)

1. Select v3 or v5 from the version dropdown in the name-based panel.
2. Choose a namespace by selecting one of the predefined options (DNS, URL, OID, X.500) or Custom.
3. If using a custom namespace, enter a valid UUID in the text field. The tool validates the format and displays an error if the UUID is malformed.
4. Enter the name in the name input field. The UUID is regenerated automatically as you type.
5. Toggle uppercase and no-dash formatting and Copy the result as in Block 1.

The name-based panel generates UUIDs on every input change — there is no separate generate button for this panel.

Tutorial

This tutorial walks through three common scenarios from opening the tool to copying the final UUID.

Scenario 1: Generate a UUID v4 for a Web Form

1. Open the tool in your browser. The UUID Generator interface shows two panels.
2. In Block 1, ensure the version dropdown is set to v4 (the default).
3. Click Generate. A UUID v4 appears, for example 550e8400-e29b-41d4-a716-446655440000.
4. Click Copy to copy the UUID to your clipboard, then paste it into your web form or API request.
5. Toggle Uppercase and click Generate again to produce 550E8400-E29B-41D4-A716-446655440000.
6. Toggle No Dashes to produce 550e8400e29b41d4a716446655440000 for compact storage or URL parameters.

Scenario 2: Generate a Time-Ordered UUID v7 for a Database Primary Key

Suppose you are designing a table in PostgreSQL that needs globally unique primary keys without a central sequence, but you also want good write performance.

1. Select v7 from the Block 1 version dropdown. The output field immediately shows a new v7 UUID, such as 018f3a6e-1a2b-7bcd-8a1b-2c3d4e5f6789.
2. Notice the first characters — UUID v7 begins with a Unix millisecond timestamp, so successive generations will show increasing values in the first groups.
3. Generate several UUIDs in rapid succession and observe that the values are monotonic: each new UUID starts with a larger or equal prefix than the previous one.
4. Copy the identifier for use in your INSERT statement: INSERT INTO users (id, name) VALUES ('018f3a6e-1a2b-7bcd-8a1b-2c3d4e5f6789', 'Alice');

Scenario 3: Generate a Deterministic UUID v5 from a Resource URL

Imagine you have a content management system where each article is identified by its URL, and you need a stable UUID that does not change between deployments.

1. In Block 2, set the version to v5.
2. Select the URL namespace from the namespace radio buttons. This uses 6ba7b811-9dad-11d1-80b4-00c04fd430c8, the standard namespace for URL-based UUIDs.
3. Enter the article URL in the Name field, for example https://example.com/articles/uuid-guide.
4. The UUID appears automatically — every time you enter the same URL with the URL namespace, you get the same UUID.
5. Test determinism: Select the DNS namespace instead, and observe that the UUID changes. Switch back to URL — the original UUID reappears.

Pro Tips

Master these advanced techniques to get the most out of the Toollect UUID Generator:

• Use v7 over v1 for database primary keys: UUID v7 sorts by millisecond timestamp from the most significant bits, giving you B-tree-friendly monotonic ordering without the complexity of MAC addresses or clock sequence management. For new projects requiring time-ordered UUIDs, start with v7.

• Prefer v5 over v3 for name-based UUIDs: Unless you are required to interoperate with a system that uses v3, always use UUID v5. SHA-1 provides more collision margin than MD5 with negligible performance difference. The tool defaults to v5 in the name-based panel for this reason.

• Remove dashes for URL parameters: Toggle No Dashes when using UUIDs in URL paths or query parameters. Without hyphens, a UUID becomes a 32-character hex string that does not require URL-encoding and is visually cleaner in route segments.

• Use predefined namespaces for consistent cross-system identifiers: The DNS, URL, OID, and X.500 namespaces are standardized in RFC 9562. Using them ensures that any RFC-compliant UUID generator produces the same v3 or v5 UUID for the same name. This is essential for cross-system identifier agreement.

• Custom namespace with a fixed v4 UUID: When creating your own namespace for v3/v5 UUIDs, generate a UUID v4 once, store it in your configuration, and reuse it. This guarantees that all identifiers within your custom namespace are distinct from any other namespace.

• Generate in batch by clicking multiple times: For small batches, rapidly clicking Generate produces distinct UUIDs each time. For large-scale generation, use the command-line or programmatic method described below.

Common UUID Misconceptions

Several widely repeated beliefs about UUIDs are inaccurate or misleading. Understanding the nuances helps you make better architectural decisions.

"UUIDs are 100% guaranteed unique." No identifier system provides absolute guarantees, but UUIDs offer astronomically high collision resistance when used correctly. For UUID v4, the probability of at least one collision across one billion generated IDs is roughly 1 in 10¹⁴. For time-based versions (v1, v6, v7), collisions across different nodes require simultaneous clock reset across multiple machines. The practical collision rate across all properly implemented UUIDs is effectively zero.

"UUID v4 is always the best choice." UUID v4 is the most general-purpose and is fine for most applications, but it is not optimal for all scenarios. For database primary keys, v4's random distribution causes index page splits and write amplification in B-tree indexes. UUID v7 offers time-sorted ordering that maintains indexes more efficiently. For deterministic identifiers that must be reproducible from a name, v3 or v5 is the only correct choice.

"UUIDs are completely random." Only UUID v4 is fully random (122 bits of entropy). UUID v1, v2, v6, and v7 embed timestamps, making them partially predictable — information that could be leaked through the identifier. UUID v3 and v5 are deterministic for a given input. If unpredictability is a requirement (security tokens, session identifiers), use v4 with the Web Crypto API.

"All UUIDs have the same format." All RFC 9562 UUIDs share the 36-character 8-4-4-4-12 hex format, but the internal structure differs radically between versions. A UUID v1 embeds MAC address and timestamp bits; UUID v4 is pure randomness; UUID v7 combines a timestamp with random bits. You can identify the version from the 13th character (4 = v4, 7 = v7, etc.) and the variant from the 17th character (8, 9, a, or b).

"UUIDs slow down database performance." This was partially true with older database versions and UUID v4 stored as ASCII strings. Modern databases (PostgreSQL with uuid type, MySQL 8+ with UUID_TO_BIN, SQL Server) store UUIDs as 16-byte binary values with native index support. UUID v7 further mitigates index fragmentation through time-ordered generation. The performance difference compared to auto-increment integers is negligible for most workloads.

Alternatives

Several alternatives to the Toollect UUID Generator exist, each suited to different workflows.

For most users who want instant, private, multi-version UUID generation without leaving the browser, the Toollect UUID Generator offers the most comprehensive feature set.

Data Privacy

The Toollect UUID Generator processes every byte of your data entirely within your browser. No data you enter — names, namespaces, or generated identifiers — is transmitted to any server, stored in any database, or logged in any system.

All generation uses JavaScript's built-in Web Crypto API (crypto.getRandomValues, crypto.randomUUID, crypto.subtle.digest). The tool page includes no analytics scripts, no tracking pixels, no cookies, and no third-party embeds. No localStorage or sessionStorage entries are created or read.

After the initial page load, the UUID Generator functions fully offline — generate identifiers even in airplane mode with zero network activity. You can verify this by inspecting the Network tab in your browser's developer tools or by disconnecting from the internet entirely.

Troubleshooting

Technical Specifications

The Toollect UUID Generator is engineered for correctness, performance, and cross-browser compatibility.

Standards Compliance

Algorithm Details per Version

Browser Compatibility

Privacy & Security

• Zero data transmission: all generation occurs in the browser's memory
• No cookies, localStorage, or sessionStorage used
• No analytics or tracking scripts on the tool page
• Fully functional in offline mode after initial page load
• No registration, login, or API keys required
• Cryptographically secure random via Web Crypto API

Features

• Generate all UUID versions v1 through v8 including time-based (v1, v6, v7), random (v4), name-based (v3, v5), DCE security (v2), and custom (v8)
• Cryptographically secure random generation using the Web Crypto API with zero network transmission
• Toggle uppercase output and remove dashes for compact or display-ready UUIDs
• Name-based UUID generation with built-in namespaces (DNS, URL, OID, X.500) and custom namespace support with validation
• 100% client-side processing — no data uploaded to any server, no sign-up or installation required
• One-click generation and copy with instant results across all modern browsers and devices

Frequently Asked Questions