UUID generator.
Generate v4, v7, v1, or nil UUIDs instantly — bulk up to 1,000, four format options, one-click copy. Cryptographically secure, browser-only, never touches a server.
no signup · no api key · rfc 4122 / 9562
· generated in-browser · — · nothing uploads
What a UUID is
A UUID is a 128-bit number written as 32 hex characters with four hyphens for readability. It's designed to be generated independently by any system on earth without coordinating with any other system and still be unique in practice — the value space is so large (2^128, or 3.4 × 10^38) that accidental collisions are effectively impossible. That's what makes UUIDs useful as primary keys, session tokens, request IDs, and anywhere you need a unique identifier without a central authority handing them out.
Which version to use
- v7 (time-sortable) — the right default for new systems in 2026. Encodes a timestamp in the first 48 bits, followed by random bits. Database indexes stay happy because new inserts append to the end of the index rather than scattering randomly. Standardized in RFC 9562 (2024).
- v4 (random) — still fine for non-indexed uses: session tokens, request IDs, ephemeral identifiers. 122 bits of cryptographically secure randomness. The most widely-deployed UUID today because it's existed forever and the tooling is mature.
- v1 (time-based legacy) — includes a timestamp and a "node" field that was originally a MAC address. Rarely the right choice today; implementations now use a random node, which makes v1 basically v4 with extra steps.
- nil (all zeros) — placeholder for "no UUID yet" or "default owner" or error states where the schema requires a UUID but there isn't a meaningful one.
How it's generated
This tool calls the browser's Web Crypto API, which browsers are required to implement using a cryptographically secure pseudo-random number generator. For v4, we use the native crypto.randomUUID() when available (Chrome 92+, Firefox 95+, Safari 15.4+) and fall back to crypto.getRandomValues() otherwise. For v7, we combine Date.now() with 74 random bits. For v1, we compute a 100-nanosecond timestamp from the Gregorian epoch and use a random node (browsers can't access a MAC address, which is the right privacy behavior).
Format options
- Standard —
550e8400-e29b-41d4-a716-446655440000— the canonical 36-character form. - Braces —
{550e8400-e29b-41d4-a716-446655440000}— the Microsoft/Windows style. SQL Server, .NET, and various Windows APIs prefer this form. - No hyphens —
550e8400e29b41d4a716446655440000— 32 characters. Common in URLs where hyphens are reserved, and in storage where fewer bytes is better. - Uppercase —
550E8400-E29B-41D4-A716-446655440000— legacy systems and some protocols mandate uppercase. The RFC technically says generators should output lowercase, but readers should accept either.
FAQ
What is a UUID?
A UUID (Universally Unique Identifier) is a 128-bit identifier formatted as 32 hexadecimal characters separated by hyphens — e.g. 550e8400-e29b-41d4-a716-446655440000. The value space is so large (2^128, roughly 3.4 × 10^38) that collisions are effectively impossible in practice, which is why UUIDs are used as primary keys, session tokens, request IDs, and anywhere an application needs a unique identifier without coordinating across systems.
What's the difference between UUID v4 and UUID v7?
v4 is pure random — 122 bits of randomness plus version and variant bits. It's still the most widely-used UUID in production, but it's not time-sortable, which means databases using UUIDs as primary keys see index fragmentation over time. v7 (standardized in RFC 9562 in 2024) fixes that by encoding a 48-bit Unix timestamp in the first 48 bits of the UUID, followed by random bits. UUIDs generated later sort after UUIDs generated earlier, which dramatically improves database index performance. For new systems in 2026, v7 is the recommended default. v4 remains fine for non-indexed uses (session tokens, request IDs, ephemeral identifiers).
Should I use UUID v1?
Usually not. UUID v1 is time-based plus a 'node' field intended to hold the MAC address of the generating machine, which was a privacy issue (UUIDs could be traced back to a specific device). Most implementations now use a random node, which makes v1 effectively equivalent to v4 but with an older, more complex format. v7 replaces v1 for every use case.
Are UUIDs really unique?
Not guaranteed unique, but effectively so. For UUID v4, the chance of generating a duplicate is negligible — you would need to generate about 2.71 billion v4 UUIDs to reach a 50% probability of a single collision (the birthday paradox). In practice, well-designed systems treat UUID uniqueness as guaranteed and don't add deduplication logic. v1 and v7 are even more collision-resistant because they include timestamp entropy.
What's a nil UUID?
A UUID of all zeros: 00000000-0000-0000-0000-000000000000. It's used as a placeholder when a UUID is required by a schema but no specific ID is available (e.g., default values, error states, 'no owner' markers). It's defined by the RFC 4122 spec specifically so applications don't have to invent their own null sentinel.
Why do UUIDs have hyphens?
Readability. The hyphens split the 128-bit value into five groups (8-4-4-4-12 hex digits) reflecting the internal field structure (time_low-time_mid-time_hi_and_version-clock_seq-node for v1, or similar boundaries for other versions). The hyphens are cosmetic — systems accept UUIDs with or without them, and the 'no-hyphens' format is common in URLs and storage (32 chars vs. 36).
Can I generate UUIDs in the browser?
Yes — that's what this tool does. Modern browsers (Chrome 92+, Firefox 95+, Safari 15.4+, Edge 92+) expose `crypto.randomUUID()` which produces cryptographically-secure v4 UUIDs. The Web Crypto API's `getRandomValues` provides the entropy needed for v7 and v1 as well. No server round-trip is needed and no network request is made — everything generates locally in your browser.
Are these UUIDs cryptographically secure?
Yes. The Web Crypto API is required to use a cryptographically-secure pseudo-random number generator. UUIDs generated here are suitable for session tokens, security identifiers, and anything else where predictability would be a problem. If you need even stronger random values for a specific cryptographic purpose (keys, nonces, salts), use the Web Crypto API directly with `crypto.getRandomValues(new Uint8Array(N))` to get exactly N bytes.
Is anything I generate uploaded or logged?
No. UUIDs are generated entirely in your browser using the Web Crypto API. No server, no network request, no log, no analytics event attached to the generated values. Your version/format/count preferences are persisted in localStorage for convenience, but those are preferences, not the UUIDs themselves.
Building something with UUIDs? You might also want the LLM token counter for pricing your AI prompts, or the freelance rate calculator for pricing your time.