What is a UUID and what is it used for?

A UUID (Universally Unique Identifier) is a 128-bit number formatted as a 36-character string of hexadecimal digits grouped by hyphens. UUIDs are used to uniquely identify records, sessions, files, events, and entities in distributed systems without requiring a central coordinator. Because the probability of two randomly generated UUIDs colliding is astronomically small, they can be generated independently on different machines and still be unique.

Are online UUID generators safe to use?

For most purposes, yes. UUID generators that run client-side in the browser use the browser's cryptographically secure random number generator (the Web Crypto API) and never send your UUIDs to a server. Server-side generators create UUIDs on the server, which is fine for non-sensitive identifiers. However, if you need UUIDs for security-critical purposes (session tokens, API keys, one-time links), generate them in your own code using a trusted library rather than copying from an online tool.

Can two UUID v4 values ever be the same?

Theoretically yes, but the probability is so small it is treated as impossible for practical purposes. UUID v4 has 122 bits of randomness, giving 5.3 x 10^36 possible values. To have a 50% chance of a collision, you would need to generate approximately 2.7 x 10^18 UUIDs — that is 2.7 quintillion. At a rate of a billion UUIDs per second, reaching that number would take about 85 years.

A NIL UUID is a special UUID where all 128 bits are set to zero: 00000000-0000-0000-0000-000000000000. It is defined in RFC 9562 as the null identifier — used as a sentinel value or placeholder when no valid UUID is available. NIL UUIDs are never valid identifiers in a production system; they signal the absence of an identifier, similar to a null pointer.

Should I use UUID v7 for database primary keys?

UUID v7 is an excellent choice for database primary keys in 2026. Because v7 UUIDs start with a timestamp, rows inserted sequentially have UUIDs that sort correctly in the index — avoiding the page fragmentation and random writes that make UUID v4 slow as a primary key in B-tree indexes. PostgreSQL 17 and MariaDB 11.7 both introduced native UUID v7 functions. For new projects, UUID v7 gives you the collision resistance of UUIDs with the index performance closer to auto-increment integers.

Best UUID Generators in 2026

Q: What is the difference between UUID v4 and UUID v7?

UUID v4 is entirely random — 122 bits of random data with no time component. It is the most widely supported and privacy-preserving option because the values are unpredictable and reveal nothing about when they were created. UUID v7 encodes a millisecond-precision Unix timestamp in the first 48 bits, followed by random data. This makes v7 UUIDs lexicographically sortable by creation time, which improves database index performance significantly compared to v4. Choose v4 for maximum privacy; choose v7 when database performance matters.

May 10, 2026 Toova

UUIDs are everywhere in modern software — database primary keys, API resource identifiers, session tokens, file names, event IDs, idempotency keys. Picking the right UUID version and the right tool to generate them matters more than it seems, especially as UUID v7 gains wide adoption in 2026.

This guide explains what each UUID version does, when to use each one, and reviews the best online UUID generators available today. Whether you need a single UUID to paste into a config file or thousands of bulk IDs for a test dataset, there is a tool here for you.

UUID Versions Explained

UUID v1 — Timestamp + MAC Address

UUID v1 was one of the original versions defined in RFC 4122. It encodes a 60-bit timestamp (100-nanosecond intervals since October 15, 1582) and the MAC address of the generating machine. The result is time-ordered and unique, but it comes with a significant privacy problem: the embedded MAC address can be used to identify the machine that generated the UUID, and the timestamp reveals exactly when it was created.

UUID v1 is not recommended for new projects. It leaks information about your infrastructure, and the MAC address embedding is a security concern in multi-tenant environments. The only legitimate reason to encounter v1 today is in legacy systems that were built before v4 became the default.

UUID v4 — Fully Random

UUID v4 is the most widely used version in production systems today. It is 122 bits of cryptographically random data with 6 fixed bits for version and variant identification. The format is:

f47ac10b-58cc-4372-a567-0e02b2c3d479

The value in the third group always starts with 4 (the version indicator), and the first character of the fourth group is always 8, 9, a, or b (the variant indicator). Everything else is random.

UUID v4 is the right default when you need a unique identifier with no ordering requirements and maximum privacy. The values are unpredictable, reveal nothing about when or where they were generated, and have effectively zero collision probability.

The downside: because v4 values are random, they create poor database index performance when used as primary keys in large tables. Random insertion into a B-tree index causes page splits and fragmentation. For write-heavy tables with millions of rows, this overhead is measurable.

UUID v7 — Timestamp-Prefixed Random

UUID v7, standardized in RFC 9562 (2024), addresses the database performance problem of v4 by encoding a millisecond-precision Unix timestamp in the first 48 bits. The remaining bits are random. The format is:

018f4b3c-d21a-7a2f-9b8e-3c4d5e6f7a8b

Because the timestamp prefix is always increasing (assuming monotonic clocks), UUIDs generated sequentially sort correctly. Rows inserted in order have UUIDs that cluster together in the index, reducing fragmentation and improving insert performance on large tables.

UUID v7 is the recommended choice for database primary keys in new projects. PostgreSQL 17, MariaDB 11.7, and MySQL 9 all added native UUID v7 support. Major ORM libraries (Hibernate, Doctrine) have followed. In 2026, there is no good reason to use v1 when you need sortable UUIDs — use v7 instead.

The trade-off: because v7 UUIDs reveal when they were created (with millisecond precision), they are not appropriate for identifiers that need to be opaque about creation time. For most database primary keys this is not a concern; for public-facing identifiers in APIs where you want to hide row creation timestamps, use v4.

NIL UUID — The Null Identifier

The NIL UUID is a special case — all 128 bits set to zero:

00000000-0000-0000-0000-000000000000

It is defined in RFC 9562 as a sentinel value representing "no UUID" — the UUID equivalent of null. Use it as a placeholder in schemas, default values, or test fixtures where you need a valid UUID format but no actual identifier. Never use a NIL UUID as a real identifier in production — it is not unique.

UUID v3 and v5 — Name-Based

UUID v3 and v5 generate deterministic UUIDs from a namespace and a name using MD5 (v3) or SHA-1 (v5) hashing. Given the same namespace and name, you always get the same UUID. This is useful for generating stable identifiers from existing data — for example, creating a UUID for a URL that stays consistent across systems.

These versions are less commonly generated via online tools (they require namespace input) and more commonly generated in code. If you need them, most UUID libraries support them.

Generating UUIDs in Code (No Library Needed)

For UUID v4, modern runtimes have built-in support:

// Browser (Web Crypto API — no library needed)
const uuid = crypto.randomUUID();
console.log(uuid);
// e.g. "f47ac10b-58cc-4372-a567-0e02b2c3d479"

// Node.js 19+ (built-in crypto module)
import { randomUUID } from 'node:crypto';
const uuid = randomUUID();
console.log(uuid);

For UUID v7, you currently need a library — native runtime support is still rolling out:

// Using the 'uuidv7' npm package
import { uuidv7 } from 'uuidv7';
const id = uuidv7();
console.log(id);
// e.g. "018f4b3c-d21a-7a2f-9b8e-3c4d5e6f7a8b"

For quick generation without writing code, an online tool is faster. For production use, always generate UUIDs in your application code rather than copying from a web page.

Top 8 UUID Generators in 2026

1. Toova UUID Generator — Best for Privacy + Bulk

Toova UUID Generator runs entirely in the browser using the Web Crypto API. Your UUIDs are generated locally — nothing is sent to a server. It supports v4, v7, and NIL generation, bulk output (1 to 1,000 UUIDs at once), multiple format options (standard hyphenated, no hyphens, uppercase, URN prefix), and one-click copy or download as a text file.

Best for: Privacy-conscious use, bulk generation, format flexibility
Privacy: 100% client-side — Web Crypto API
Versions: v4, v7, NIL
Bulk: Up to 1,000 at once
Formats: Standard, no hyphens, uppercase, URN

2. UUID Generator (uuidgenerator.net) — The Popular Classic

uuidgenerator.net has been one of the most visited UUID tools for years. It generates v1 and v4 UUIDs, offers bulk generation, and has a clean interface. Processing is server-side — the UUIDs are generated on the server and returned to your browser.

Best for: Quick single UUIDs, non-sensitive use
Privacy: Server-side
Versions: v1, v4
Bulk: Yes
Formats: Standard

3. Online UUID Generator (uuidtools.com) — Broad Version Support

uuidtools.com generates v1, v3, v4, and v5 UUIDs, with a dedicated page for each version. The v5 and v3 generators accept namespace and name inputs correctly. Useful when you need name-based UUIDs without setting up a library. Server-side processing.

Best for: v3/v5 name-based UUID generation
Privacy: Server-side
Versions: v1, v3, v4, v5
Bulk: Limited

4. FreeFormatter UUID Generator — Feature-Rich

FreeFormatter's UUID tool supports v1, v3, v4, and v5 with namespace inputs for the name-based versions. It also offers bulk generation up to 100 UUIDs. The interface is dated but functional. Server-side.

Best for: Multiple version support, small bulk batches
Privacy: Server-side
Versions: v1, v3, v4, v5
Bulk: Up to 100

5. UUID Generator (guidgenerator.com) — GUID Focus

GUID (Globally Unique Identifier) is Microsoft's term for UUID. guidgenerator.com generates GUIDs (v4 UUIDs) and outputs them in Microsoft-friendly formats including curly-brace notation ({guid}) and C# struct format. Useful for .NET developers. Server-side.

Best for: .NET / C# development workflows
Privacy: Server-side
Versions: v4 (GUID)
Bulk: Yes
Formats: Hyphenated, no hyphens, curly braces, C#, VB.NET

6. UUID v7 Generator (uuid7.com) — Specialized for v7

uuid7.com is a dedicated generator for the UUID v7 spec. It shows the timestamp embedded in each UUID and explains the bit layout. Client-side generation. Useful for learning the v7 format or validating that a UUID v7 library is encoding timestamps correctly.

Best for: UUID v7 specifically, learning the format
Privacy: Client-side
Versions: v7
Bulk: Limited

7. Mockaroo UUID Column — Data Generation in Context

Mockaroo is a data generation platform that supports UUID v4 as a column type when generating test datasets. If you need UUIDs as part of a larger dataset (mixed with names, emails, addresses), Mockaroo generates them in context. The free tier allows generating up to 1,000 rows. Server-side.

Best for: UUIDs as part of larger test datasets
Privacy: Server-side
Versions: v4
Bulk: Up to 1,000 rows (free tier)

8. generateuuid.net — Minimal and Fast

generateuuid.net is a stripped-down single-purpose tool. Load the page, get a UUID. There is no form to fill out — the UUID appears immediately. Click to regenerate. It is the fastest option when you literally just need one UUID and do not care about format options. Server-side.

Best for: Fastest possible single UUID
Privacy: Server-side
Versions: v4
Bulk: No

UUID v4 vs. UUID v7 — Which Should You Use?

This is the most important UUID decision in 2026. Here is the practical guide:

Use UUID v4 when:

You need identifiers that reveal no information about creation time
You are using UUIDs as public API identifiers that clients will store
Your database table has fewer than a few hundred thousand rows (index fragmentation is not a concern at small scale)
You are using a runtime with built-in v4 support (crypto.randomUUID() in browsers and Node.js) and do not want to add a dependency
The existing codebase uses v4 and you want consistency

Use UUID v7 when:

You are designing a new database schema and the table will grow large
You need time-ordering built into the identifier (for example, sorting events by ID gives you chronological order)
You are on PostgreSQL 17+, MariaDB 11.7+, or MySQL 9+ and want native database-level generation
You want the benefits of distributed ID generation (no sequence coordination) with better index locality than v4

For most new projects in 2026, UUID v7 is the better default for database primary keys. For API surface identifiers that are exposed to clients, v4 remains the better choice because it reveals nothing about your data timeline.

You can also combine them: use UUID v7 as internal primary keys (stored in the database, not exposed externally) and UUID v4 as the public-facing API identifier for the same resource. This is more complex but gives you both benefits.

For generating random strings that are not UUIDs — for example, API keys, tokens, or short codes — see the random string generator and password generator, which offer additional control over character sets and length.

Comparison Table

Tool	Privacy	v4	v7	NIL	v3/v5	Bulk	Formats
Toova	Client-side	Yes	Yes	Yes	No	1–1,000	4 options
uuidgenerator.net	Server	Yes	No	No	No	Yes	Standard
uuidtools.com	Server	Yes	No	No	Yes	Limited	Standard
FreeFormatter	Server	Yes	No	No	Yes	Up to 100	Standard
guidgenerator.com	Server	Yes	No	No	No	Yes	5 .NET formats
uuid7.com	Client-side	No	Yes	No	No	Limited	Standard

Conclusion

UUID generation is a solved problem — any reliable tool will produce collision-resistant identifiers. The meaningful differences between tools come down to version support, privacy, bulk generation, and format flexibility.

For everyday use, Toova UUID Generator covers the most important bases: v4 for the default case, v7 for new database schemas, NIL for testing, bulk output for dataset generation, and multiple formats — all client-side. For specialized use cases, uuid7.com is the best client-side v7 tool, and uuidtools.com is the right choice when you need v3/v5 name-based generation.

When you need UUIDs in your own code, skip the online tool entirely: crypto.randomUUID() is available in all modern browsers and Node.js 19+, producing a cryptographically secure v4 UUID with no dependencies. Add uuidv7 from npm for v7 support until native runtime APIs catch up. The full UUID specification is documented in RFC 9562.

Ready to generate? Try the Toova UUID Generator — no signup, no server round-trip, 1,000 UUIDs in one click.