UUID Generator — v4, v7, v1 & Nil

Generate cryptographically random UUIDs directly in your browser. Choose v4 (random), v7 (time-ordered), v1 (timestamp), or Nil. Nothing is uploaded — every UUID is generated locally on your device.

Random UUID — the most common format, 122 bits of entropy.

Format

Free UUID Generator — v4, v7, v1 and Nil

This is a free online UUID generator that creates universally unique identifiers directly in your browser. Pick a version, choose how many you need, and get them instantly — no signup, no tracking, no server round-trip. Every UUID is generated locally using the Web Crypto API, the same cryptographic source browsers use for TLS and password managers, so the values never leave your device.

Generate a single UUID or batch up to 100 at a time. Copy them individually, copy the full list with one click, or download the batch as a .txt file. Format options let you switch to UPPERCASE, strip the hyphens, or wrap every value in curly braces — useful when you’re pasting into C#, SQL Server, or a config file that expects a specific style.

Which UUID version should you use?

UUID v4 — random (the default)

UUID v4 is the version you’ve seen everywhere. It packs 122 bits of cryptographic randomness into a 128-bit value, which means collisions are astronomically unlikely — you would need to generate about one billion UUIDs per second for 85 years to have a 50% chance of a single duplicate. v4 is the safe default for session tokens, idempotency keys, file names, API request IDs, and any scenario where you need a unique value without coordinating across systems.

UUID v7 was standardized in RFC 9562 in 2024 and is now the recommended format for new systems, especially anything that stores UUIDs as database primary keys. It embeds a 48-bit Unix timestamp (milliseconds) at the front of the value, so IDs generated later sort after IDs generated earlier. The practical payoff is much better insert performance on B-tree indexes in PostgreSQL, MySQL, and SQL Server — new rows land at the end of the index instead of scattering across it, which dramatically reduces page splits on large tables. If you’re starting a new project and have a choice, prefer v7 over v4 for primary keys.

UUID v1 — timestamp + node (legacy)

UUID v1 combines a 60-bit timestamp (100-nanosecond intervals since 1582-10-15) with a node identifier. It’s kept around mostly for compatibility with older systems that already use v1 IDs. For anything new, v7 is a better time-ordered option because it sorts naturally in lexicographic order and doesn’t leak MAC addresses.

Nil UUID — the all-zero placeholder

The Nil UUID is the special value 00000000-0000-0000-0000-000000000000. It’s not random — it’s a fixed constant used as a “not set” sentinel or a schema default when a UUID column is required but no real value exists yet. Think of it as the UUID equivalent of NULL.

How to generate a UUID with this tool

  1. Pick the version tab you want — v4, v7, v1, or Nil.
  2. Set the count (1 to 100). Use the plus and minus buttons or type directly.
  3. Optionally toggle UPPERCASE, No hyphens, or Braces { } to match the format your codebase expects.
  4. Click Generate. Copy individual values, copy the whole list, or download as .txt.

Changing the format toggles re-renders the visible list with the current settings — no regeneration is needed unless you want fresh values.

Common use cases

  • Database primary keys — prefer v7 so inserts don’t fragment your index.
  • Distributed IDs — two services can generate UUIDs at the same time without coordinating and still never collide.
  • Session tokens and API keys — v4 gives you 122 bits of unpredictable randomness.
  • Idempotency keys — attach a v4 UUID to each client request so retries are safe.
  • File names and object storage keys — avoid name collisions when many clients upload in parallel.
  • Test fixtures and seed data — Nil is handy as a known “unassigned” sentinel.

Privacy, speed, and offline use

Every UUID on this page is generated locally in your browser with crypto.getRandomValues. Nothing is sent to a server, nothing is logged, and the tool keeps working if you disconnect from the internet after the page loads. Generating 100 UUIDs takes a few milliseconds — the limit is UI rendering, not cryptography.

If you need UUIDs on the command line or inside code, every modern language ships a UUID library (uuid in Python, crypto.randomUUID() in Node.js, Guid.NewGuid() in .NET). This tool exists for the case in between: when you need a handful of real, correctly-formatted UUIDs right now without opening an editor.

FAQ

Frequently Asked Questions

A UUID (Universally Unique Identifier) is a 128-bit value used to identify something uniquely without a central registry. Written as 32 hexadecimal digits split by hyphens into five groups (8-4-4-4-12), it is designed so that the probability of two independent parties generating the same ID is negligible. UUIDs are used as database primary keys, session tokens, distributed IDs, and any time you need a unique identifier without coordinating across systems.

For most applications, use v4. It is 122 bits of cryptographic randomness and is widely supported. Use v7 when you need time-ordered IDs — it gives much better database index locality than v4 and is the current recommendation for new systems that insert frequently. Use v1 for compatibility with legacy systems. Use Nil (the all-zero UUID) as a placeholder or "not set" sentinel value.

v4 is fully random, so every UUID is completely unordered — that hurts database index performance because new rows land in random parts of the index. v7 embeds a 48-bit Unix timestamp in milliseconds at the start of the UUID, so IDs generated later sort after IDs generated earlier. This gives v7 much better insert performance on B-tree indexes while still being globally unique. v7 was standardized in RFC 9562 in 2024 and is now the recommended format for new systems.

v4 UUIDs have 122 bits of randomness, which is about 5.3 x 10^36 possible values. You would need to generate about one billion UUIDs per second for 85 years to have a 50% chance of a single collision. For any practical application, treat v4 UUIDs as unique. v7 further reduces collision risk by prefixing with a timestamp, so collisions can only happen within the same millisecond.

Yes. Generation happens entirely in your browser using the Web Crypto API (crypto.getRandomValues), the same cryptographic source used by TLS, password managers, and banking applications. Nothing is sent to a server, logged, or stored. You can disconnect from the internet after the page loads and the tool keeps working.

Yes, but pick the right version. For new systems, prefer v7 — the embedded timestamp gives you roughly time-ordered inserts, which is dramatically faster on B-tree indexes used by MySQL, PostgreSQL, and SQL Server. v4 works too but scatters inserts across the index, causing more page splits and slower writes on large tables. Both are 128 bits, so storage is identical.

The Nil UUID is the special all-zero UUID: 00000000-0000-0000-0000-000000000000. It is used as a placeholder when a UUID field is required but no real value exists yet — for example, a default value in a schema, a "not set" sentinel, or a test fixture. Treat it as equivalent to NULL or "unassigned".

Yes. Once the page has loaded, the UUID generator works entirely offline. All generation happens locally in your browser using JavaScript and the Web Crypto API. No internet connection is needed after the initial page load.