🧰 ToolPicoAll Tools →
🆔 Developer Tool · UUID/GUID Generator

UUID Generator

Generate v4 random, v1-like timestamped, v3/v5 name-based, and v7 time-ordered UUIDs/GUIDs. Bulk-generate up to 1,000 at once, with format options and a validator — all in your browser, nothing is ever sent to a server.

🔒 100% in your browser 5 UUID modes + ULID Bulk up to 1,000 Updated: Jul 19, 2026
122 bits of cryptographic randomness (crypto.getRandomValues) plus fixed version/variant bits.
No real MAC address is used. A "node" value is randomly generated on every run, with the multicast bit set (as recommended by RFC 4122) to flag that it isn't a real hardware address.
The same namespace + the same name always produces the same UUID (deterministic) — not random.
The first 48 bits are a millisecond timestamp — v7 UUIDs generated in sequence also sort in time order, alphabetically/numerically. Recommended for database primary keys.
Enter a standard, no-hyphen, braced ({}), or urn:uuid:-prefixed UUID, or a 26-character ULID — for v1, v7, and ULID the embedded creation time is also decoded in UTC/local.
Quick answer UUID Generator creates RFC 4122/9562-compliant v4 (random), v1-like (timestamped), v3/v5 (name-based), and v7 (time-ordered) UUID/GUID values in your browser, using cryptographically secure crypto.getRandomValues. It supports bulk generation of up to 1,000 at once, format options, and a validator — no data is ever sent to a server.
128 bitUUID length (16 bytes)
5Versions (v1, v3, v4, v5, v7)
100%Browser-side, private
1,000Bulk generation limit
🔒 Privacy: All generation and validation happen in your browser; no input or generated UUID is ever sent to, stored by, or logged on a server. Randomness comes from the browser's built-in Web Crypto API (crypto.getRandomValues); MD5/SHA-1 hashing for v3/v5 mode is also computed with our own pure JavaScript / Web Crypto code — no external library or CDN is used. Only when you click "Copy link" are your settings (and, in v3/v5 mode, the name field) encoded into a shareable address.

What is a UUID, and what are its versions?

A complete explanation of RFC 4122/9562 UUID versions, when to use each one, and how a GUID differs.

A UUID (Universally Unique Identifier) is a 128-bit (16-byte) identifier that's considered unique for practical purposes even when generated without a central authority. In standard text form it's written as 32 hexadecimal characters and 4 hyphens, grouped 8-4-4-4-12 (e.g. 550e8400-e29b-41d4-a716-446655440000). This tool can generate every version defined by RFC 4122 and the current RFC 9562 — v1, v3, v4, v5, and v7.

How is a v4 UUID generated?

Quick answerA v4 UUID fills 122 of its 128 bits with output from a cryptographically secure random number generator (in the browser, crypto.getRandomValues); the remaining 6 bits carry the fixed version (0100) and variant (10) values. The chance of two different v4 UUIDs colliding is statistically negligible.

What is the difference between UUID v1 and v4?

Quick answerv1 embeds the timestamp of the moment it was created and a node ID (classically, a MAC address); it can theoretically be traced back to a creation time and machine. v4 is entirely random and carries no time or machine information. The "v1-like" mode in this tool uses a randomly generated node ID instead of a real MAC address — it never reads actual hardware information.

How do v3 and v5 name-based UUIDs work?

Quick answerv3 (MD5) and v5 (SHA-1) are generated by combining a namespace UUID with a name (e.g. a domain name) and hashing the result. The same namespace + the same name always produces the same UUID — so it's deterministic, not random. This is used when different systems need to derive the same identifier from the same data (e.g. always finding the same record from a given URL).

What is UUID v7, and why is it recommended for databases?

Quick answerv7 is a newer UUID version (RFC 9562) whose first 48 bits carry a millisecond-precision timestamp, with the remaining bits random. Because of this, v7 UUIDs generated in sequence also sort lexicographically in time order — something a v4 UUID can't do — which gives database indexes a performance advantage by reducing B-tree fragmentation.

What is the difference between a GUID and a UUID?

Quick answerGUID is Microsoft's name for the same 128-bit structure; it's based on the same RFC 4122 standard. The only practical difference is usually formatting: in .NET, GUIDs are often shown wrapped in braces ({550e8400-e29b-41d4-a716-446655440000}). This tool can produce that format with the "{ } .NET" format option.

Extra mini tools: NIL UUID, ULID & Base64 converter

Three extra mini tools inspired by competitor UUID tools: a fixed empty UUID, a sortable ULID identifier, and a UUID-to-Base64/Hex converter.

NIL UUID
A special, fixed UUID with every bit set to zero — used to represent "empty" or "no value."
🕒Generate ULID
128 bits, 26-character Crockford Base32 — sortable because the first 48 bits are a timestamp.
🔁UUID → Base64/Hex
Show a UUID's 16 bytes as Base64 and plain hex — for a shorter representation in tokens or URLs.

UUID versions & format reference tables

A citable version comparison, format examples, and a UUID/GUID/ULID comparison.

UUID versions — RFC 4122 / RFC 9562
VersionSource dataSortable?Typical use
v1Timestamp + node IDPartiallyLegacy systems, backward compatibility
v3Namespace + name (MD5)NoDeterministic ID (legacy)
v4Fully randomNoGeneral purpose, most common
v5Namespace + name (SHA-1)NoDeterministic ID (recommended)
v7Timestamp + randomYesDatabase primary keys
ULID (extra)Timestamp + random (Base32)YesSortable, short-string ID
Format variations of the same v4 UUID
FormatExample
Standard (lowercase)550e8400-e29b-41d4-a716-446655440000
Uppercase550E8400-E29B-41D4-A716-446655440000
No hyphens550e8400e29b41d4a716446655440000
Braces (.NET GUID){550e8400-e29b-41d4-a716-446655440000}
URN prefixurn:uuid:550e8400-e29b-41d4-a716-446655440000
Base64 (16 bytes)VQ6EAOKbQdSnFkRmVUQAAA==
UUID vs GUID vs ULID
PropertyUUIDGUIDULID
Bit length128128 (same standard)128
Text length36 characters36 (or 38 with braces)26 characters
AlphabetHex (0-9, a-f) + hyphensHex + hyphensCrockford Base32
Sorts in time order?Only v1/v7Only v1/v7Yes (by default)
Common useGeneral purpose.NET / Windows ecosystemDatabase keys, log IDs

Language-specific code examples: how to generate a UUID

Ready-to-copy UUID/GUID generation code for Python, JavaScript/Node, Java, C#, Go, PHP, PostgreSQL, and MySQL. Each shows that language's standard approach.

Python 3 — the built-in uuid module, no install needed.
# Standard library, no install needed
import uuid

# v4 (random) — most common use
print(uuid.uuid4())          # 550e8400-e29b-41d4-a716-446655440000

# v5 (name-based, SHA-1) — deterministic
print(uuid.uuid5(uuid.NAMESPACE_DNS, "example.com"))

# v1 (time + node)
print(uuid.uuid1())

# Text formats
u = uuid.uuid4()
print(u.hex)                 # no hyphens
print(str(u).upper())        # uppercase
JavaScript / Node.js — built-in crypto.randomUUID() in modern browsers and Node 19+.
// Browser + Node 19+ (built-in, v4)
const id = crypto.randomUUID();
console.log(id);             // 550e8400-e29b-41d4-a716-446655440000

// Node.js (via the crypto module)
import { randomUUID } from "node:crypto";
console.log(randomUUID());

// Uppercase / no hyphens
console.log(id.toUpperCase());
console.log(id.replace(/-/g, ""));
Java — the built-in java.util.UUID class (v4 random and v3 name-based).
import java.util.UUID;

// v4 (random)
UUID id = UUID.randomUUID();
System.out.println(id);      // 550e8400-e29b-41d4-a716-446655440000

// v3 (name-based, MD5)
UUID named = UUID.nameUUIDFromBytes("example.com".getBytes());
System.out.println(named);

// Parse from text
UUID parsed = UUID.fromString("550e8400-e29b-41d4-a716-446655440000");
C# / .NET — the Guid struct. .NET 9 also adds time-ordered Guid.CreateVersion7().
using System;

// v4-like GUID (random)
Guid id = Guid.NewGuid();
Console.WriteLine(id);              // 550e8400-e29b-41d4-a716-446655440000
Console.WriteLine(id.ToString("B")); // {550e8400-...} .NET GUID format
Console.WriteLine(id.ToString("N")); // no hyphens
Console.WriteLine(id.ToString("D").ToUpper()); // uppercase

// .NET 9+: v7 (time-ordered, database-friendly)
Guid v7 = Guid.CreateVersion7();
Go — the popular github.com/google/uuid package (go get github.com/google/uuid).
package main

import (
    "fmt"

    "github.com/google/uuid"
)

func main() {
    fmt.Println(uuid.New())     // v4 (random)

    // v5 (name-based, SHA-1)
    fmt.Println(uuid.NewSHA1(uuid.NameSpaceDNS, []byte("example.com")))

    // v7 (time-ordered) — google/uuid v1.6+
    v7, _ := uuid.NewV7()
    fmt.Println(v7)
}
PHP — the ramsey/uuid package (composer require ramsey/uuid).
use Ramsey\Uuid\Uuid;

// v4 (random)
echo Uuid::uuid4()->toString();   // 550e8400-e29b-41d4-a716-446655440000

// v7 (time-ordered, database-friendly)
echo Uuid::uuid7()->toString();

// v5 (name-based, SHA-1) — deterministic
echo Uuid::uuid5(Uuid::NAMESPACE_DNS, "example.com")->toString();
PostgreSQLgen_random_uuid() is built in on 13+ (older versions need the pgcrypto extension).
-- Generate a v4 (random) UUID
SELECT gen_random_uuid();

-- Automatic default on a table column
CREATE TABLE users (
  id    uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  name  text NOT NULL
);

-- Older versions (PostgreSQL 12 and earlier):
-- CREATE EXTENSION IF NOT EXISTS pgcrypto;
MySQL 8UUID() generates a v1-based value; UUID_TO_BIN(..., 1) is recommended for sorted storage.
-- Generate a text UUID (v1-based)
SELECT UUID();

-- Store as a sorted 16-byte BINARY (index-friendly)
SELECT UUID_TO_BIN(UUID(), 1);

CREATE TABLE users (
  id    BINARY(16) PRIMARY KEY,
  name  VARCHAR(120) NOT NULL
);

-- Convert back to text when reading:
-- SELECT BIN_TO_UUID(id, 1) FROM users;

UUID terms glossary

Short definitions of the core concepts used when discussing UUIDs/GUIDs.

UUID / GUIDA 128-bit identifier considered unique for practical purposes; defined by the RFC 4122/9562 standard.
Version nibbleThe 13th hex character of a UUID; indicates which version (1, 3, 4, 5, 7) generated it.
Variant bitsThe leading bits of the 17th hex character; indicate whether the UUID conforms to RFC 4122 (usually 8, 9, a, or b).
CSPRNGA cryptographically secure random number generator; provided in the browser by crypto.getRandomValues.
Namespace UUIDA fixed prefix UUID combined with a name during v3/v5 generation (DNS, URL, OID, X.500, or custom).
Nil UUIDA special UUID with every bit set to zero (00000000-0000-0000-0000-000000000000); means "no value."
Node IDThe 48 bits classically derived from a MAC address in a v1 UUID; generated randomly in this tool for safety.
ULIDA sortable, 26-character identifier combining a timestamp and randomness, encoded with Crockford Base32.
Crockford Base32A 32-character alphabet that excludes the letters I, L, O, and U to reduce reading confusion.
CollisionTwo different generation events producing the same identifier; statistically negligible for v4.
Monotonic orderingSuccessively generated identifiers increasing/sorting in the order they were created (true for v7 and ULID).
RFC 4122 / RFC 9562The IETF standards defining UUIDs; RFC 9562 updates RFC 4122 and adds v6/v7/v8.

In-depth guides

Detailed answers to the most common UUID questions.

Which UUID version should I use?

For most scenarios, v4 (fully random) is a good default: it's simple, privacy-friendly, and leaks no information. If you'll use it as a database primary key and index performance matters, prefer v7; because sequentially generated v7 values sort in time order, they cause less B-tree index fragmentation.

If you need to always derive the same identifier from the same input (e.g. a URL or email address), use v5 (SHA-1-based); v3 (MD5-based) is kept only for legacy system compatibility. Reach for v1 only when working with older systems that require it for backward compatibility.

For a database primary key: UUID, auto-increment, or ULID?

Auto-incrementing integers index the fastest, but can collide in distributed systems (when multiple servers insert records simultaneously) and reveal the row count publicly. A v4 UUID never collides, but being fully random it can fragment B-tree indexes and slow down writes.

v7 UUID or ULID solves this with a timestamp prefix: neither collides, and because they're inserted in sequence their index performance is close to auto-increment. ULID is also shorter (26 characters vs. UUID's 36); the choice usually comes down to what your ecosystem (ORM/database) supports.

How low is the v4 UUID collision probability, really?

A v4 UUID has 122 randomly generated bits, giving 2122 (≈5.3 × 1036) possible values. Using the birthday-paradox calculation, you'd need to generate roughly 2.71 quintillion (2.71 × 1018) UUIDs before reaching a 50% chance of a collision — a practically impossible scale, equivalent to every person on Earth generating billions of UUIDs every second.

For this reason, v4 UUIDs are safely treated as "unique" in real-world applications. That said, the quality of the random number generator matters; this tool uses the cryptographic crypto.getRandomValues instead of the insecure Math.random().

Add this tool to your site (embed code)

Embed the UUID generator on your own website for free. Copy the code below into your HTML — the tool runs in a simplified view and links back to this page as its source.

The embedded tool has a fixed layout; you can adjust the height value to fit your site. No ads or personal data, runs entirely client-side.

Frequently asked questions

What is a UUID?
UUID (Universally Unique Identifier) is a 128-bit (16-byte) identifier considered unique for practical purposes. In standard notation it's written as 32 hex characters and 4 hyphens in an 8-4-4-4-12 pattern. It's defined by RFC 4122/9562 and used anywhere a unique identifier is needed without a central authority — database keys, session IDs, and more.
How is a v4 UUID generated?
A v4 UUID fills 122 bits of the 128 total from a cryptographic random number generator (crypto.getRandomValues); the remaining bits carry fixed version (0100) and variant (10) values. This makes collision probability statistically negligible.
What is the difference between a GUID and a UUID?
GUID is Microsoft's name for the same 128-bit structure; it's based on the same RFC 4122 standard. The only real difference is usually formatting: in .NET, GUIDs are often shown wrapped in braces ({...}). You can produce that format here with the "{ } .NET" option.
How do I generate UUIDs in bulk?
Enter a number from 1 to 1,000 in the quantity field, or pick a preset chip, then click "Generate." Results are listed one per line; copy them all with one click or download them as .txt/.csv.
How many characters or bytes long is a UUID?
As raw data, 128 bits / 16 bytes. In standard text form: 32 hex characters + 4 hyphens = 36 characters; without hyphens, 32; wrapped in braces (.NET GUID style), 38.
Is an online UUID generator safe to use?
Yes. All generation and validation happen in your browser; it uses crypto.getRandomValues, and no input or generated UUID is ever sent to, stored on, or logged by a server. No external library or CDN is used.
What is the difference between UUID v1 and v4?
v1 embeds the timestamp of creation and a node ID (classically a MAC address); it can theoretically be traced. v4 is entirely random. The "v1-like" mode here uses a randomly generated node ID instead of a real MAC address.
What is a ULID, and how does it differ from a UUID?
ULID carries 128 bits like a UUID but is encoded with 26-character Crockford Base32, and its first 48 bits are a millisecond timestamp. That means it also sorts in time order alphabetically, which can give database indexes a performance advantage.
How can I find out when a v7 or v1 UUID was generated?
v1 and v7 UUIDs, and ULIDs, carry an embedded creation timestamp. When you paste one into the Validate tab, in addition to version/variant information, the embedded timestamp is decoded and shown in both UTC and local time. The first 48 bits of a v7 UUID are a Unix millisecond timestamp; a v1 UUID carries the number of 100 ns ticks since 1582; the first 10 Base32 characters of a ULID carry a millisecond timestamp. v3/v4/v5 carry no time information, so no date can be decoded from them.
How do you generate a UUID in Python, C#, PostgreSQL, and similar languages?
The Code examples section on this page has copyable blocks. In short: Python uuid.uuid4(), JavaScript/Node crypto.randomUUID(), Java UUID.randomUUID(), C#/.NET Guid.NewGuid(), Go uuid.New(), PHP Uuid::uuid4(), PostgreSQL gen_random_uuid(), MySQL UUID(). Name-based (v5) and time-ordered (v7) examples are in the same section.
Can I get the output as quoted, comma-separated, or URL-encoded UUIDs?
Yes. In the format bar, enable Quoted to wrap every UUID in double quotes (handy for code arrays or SQL), or Comma-separated to join the list on one line instead of one per line. For URL/query-string use, toggle URL-encoded output instead of Base64 output — only one of the two can be active at a time.

Methodology & sources

ToolPico's UUID Generator is a free, independent UUID/GUID generation tool. v4 and v7 randomness is produced with the browser's standard Web Crypto API (crypto.getRandomValues). For v3/v5 name-based generation, MD5 is computed with our own pure JavaScript implementation (RFC 1321), and SHA-1 with the Web Crypto API (crypto.subtle.digest) — no external library or CDN is used. In v1-like mode, no real hardware/MAC information is ever read; the node ID is randomly generated on every run.

Sources: RFC 4122 (A Universally Unique IDentifier) · RFC 9562 (the current UUID standard, adding v6/v7/v8) · W3C Web Cryptography API · the official ULID specification (Crockford Base32). Last updated: July 19, 2026. Results are algorithmic; v3/v5 are deterministic, while v1/v4/v7 and ULID rely on cryptographic randomness.
Explore all ToolPico tools →

🔗 Add this tool to your site

Copy the code below into your own site. The tool is free, always up to date, and runs entirely on your page. No sign-up required.

Preview →
⚡ Built with ToolPico · toolpico.com