UUID / GUID Generator

Generate UUID v4 (random) or UUID v1 (timestamp) — single or bulk, 100% in-browser

Version

Count

UUIDs

Click Generate to create UUIDs

Version: v4

Count: 1

Format: lowercase with hyphens

Generated: 0

UUID Validator

Paste any UUID string to check its validity and version

Free Online UUID / GUID Generator — No Signup Required

Generate cryptographically secure UUIDs (Universally Unique Identifiers) instantly — UUID v4 (random) or UUID v1 (timestamp-based). Bulk generate up to 100 UUIDs at once, format as uppercase/lowercase, with or without hyphens, and copy any single UUID or the entire batch. Processing runs entirely in your browser using the native crypto.randomUUID() API — no data is sent to any server, no signup required.

How to Use This UUID Generator

Select v4 (random) or v1 (timestamp-based) UUID version at the top
Choose how many UUIDs to generate: 1, 5, 10, 25, 50, or 100
Toggle Uppercase to get uppercase hex output (useful for .NET and Windows APIs)
Toggle Hyphens off to get compact UUID format without separators
Click Generate — UUIDs appear instantly in the output list
Click any UUID's individual Copy button to copy just that UUID
Use Copy All in the panel header to copy all UUIDs as a newline-separated block
Scroll down to the UUID Validator and paste any UUID string to check its validity and version

What is a UUID?

A UUID (Universally Unique Identifier) is a 128-bit label used to uniquely identify objects in computer systems without requiring central coordination. UUIDs are standardized by RFC 4122 (and the newer RFC 9562).

In their canonical textual form, UUIDs are represented as 32 lowercase hexadecimal digits displayed in five hyphen-separated groups:

550e8400-e29b-41d4-a716-446655440000
xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
         (M = version nibble, N = variant bits)

The total length is always 36 characters including hyphens (32 hex + 4 hyphens). The version nibble (M) tells you which UUID version was used to generate it. GUID (Globally Unique Identifier) is Microsoft's name for the same standard. GUIDs and UUIDs are identical — the terms are fully interchangeable. GUID is the preferred term in .NET, COM, and Windows APIs; UUID is the cross-platform RFC term used in databases, cloud services, and open standards.

UUID v4 vs v1 — Which Should You Use?

UUID v4 is the standard choice for nearly all modern applications. It is generated from 122 bits of cryptographic randomness using the OS's CSPRNG (the same entropy source as TLS). UUID v4 contains no system information, is completely unpredictable, and is safe for database primary keys, API tokens, session identifiers, and file names.

UUID v1 encodes the current timestamp (at 100-nanosecond resolution since October 15, 1582) and a node identifier. v1 UUIDs are monotonically increasing within a single node, providing natural sort order. However, they expose system information. This tool generates v1 UUIDs with a random node ID (not a real MAC address) to protect privacy.

UUID Version Comparison

Version	Generation method	Sortable	Privacy-safe	Best use case
v1	Timestamp + MAC address	Yes (per node)	No — leaks time & node	Time-ordered IDs in controlled environments
v3	MD5 hash of namespace + name	No	Yes	Deterministic name-based IDs (prefer v5)
v4	Cryptographically random	No	Yes	Database keys, tokens, session IDs — general use
v5	SHA-1 hash of namespace + name	No	Yes	Deterministic name-based IDs (preferred over v3)
v7	Unix timestamp + random	Yes (globally)	Yes	DB primary keys where index locality matters (PostgreSQL, MySQL)

UUIDs as Database Primary Keys

UUIDs make excellent database primary keys when you need globally unique IDs without a central sequence generator. PostgreSQL has a native UUID type stored as 16 bytes. Use gen_random_uuid() (built-in from Postgres 13). MySQL stores UUIDs as CHAR(36) or more efficiently BINARY(16) with UUID_TO_BIN(). UUID v4 causes B-tree page splits (random insertion); UUID v7 (time-ordered) solves this.

When working with JSON data that contains UUID fields, use our JSON Formatter to inspect and format JSON payloads. Need to hash UUIDs or verify file integrity? Try the Hash Generator.

Frequently Asked Questions

What is a UUID?

A UUID (Universally Unique Identifier) is a 128-bit label used to uniquely identify objects in computer systems. UUIDs are standardized by RFC 4122. In their canonical form they are 32 hexadecimal digits in 5 groups: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. The probability of two identical UUIDs is astronomically low — about 1 in 5.3 × 10³⁶.

What is the difference between UUID and GUID?

Nothing — they are the same thing. GUID (Globally Unique Identifier) is Microsoft's term for the UUID standard (RFC 4122). The terms are interchangeable. GUID is common in .NET and Windows ecosystems; UUID is the cross-platform term used everywhere else including databases, REST APIs, and open standards.

What is UUID v4 vs UUID v1?

UUID v4 is purely random — 122 bits from a cryptographically secure RNG. It reveals nothing about the generating machine or time. UUID v1 encodes the current timestamp and the machine's MAC address. v1 is sortable but exposes system information. For most use cases — database keys, API tokens, session IDs — UUID v4 is the correct choice.

Are UUIDs truly unique?

For practical purposes, yes. UUID v4 has 2¹²² possible values (≈5.3 × 10³⁶). Even generating 1 billion UUIDs per second for 100 years, the probability of a collision is negligible. UUID uniqueness is the foundation of distributed systems that need to generate IDs independently without any central coordination.

How do I use UUIDs as database primary keys?

UUIDs work well as primary keys when you need globally unique IDs across distributed systems, want to prevent sequential ID enumeration (a security concern with integer keys), or generate IDs client-side before inserting into the database. PostgreSQL has a native UUID type. MySQL stores them as BINARY(16) or CHAR(36). The tradeoff vs integer keys is storage size (16 bytes vs 4–8 bytes) and worse B-tree index locality with random v4 UUIDs. UUID v7 (time-ordered) solves the index locality problem.

Is this UUID generator cryptographically secure?

Yes. UUID v4 uses the browser's built-in crypto.randomUUID(), which calls the operating system's cryptographically secure PRNG (the same entropy source used by TLS). The generated UUIDs are safe for security tokens, session IDs, and cryptographic nonces. UUID v1 in this tool uses crypto.getRandomValues() for the node ID to avoid exposing a real MAC address.

What is UUID v7 and should I use it?

UUID v7 (defined in RFC 9562, published 2024) is a time-ordered UUID that combines a Unix millisecond timestamp with random bits. Unlike v4, v7 UUIDs sort chronologically, which dramatically improves B-tree index performance in databases. UUID v7 is the modern recommendation for new database primary key columns. Browser support for generating v7 natively does not yet exist; use a server-side library (e.g., the uuid npm package v10+).

How do I generate a UUID in JavaScript?

Modern browsers and Node.js 19+ provide crypto.randomUUID() natively — no library needed. For older Node.js, use the uuid npm package: import { v4 as uuidv4 } from 'uuid';. In Python, use import uuid; str(uuid.uuid4()). In Go, use the github.com/google/uuid package.

What does a UUID look like in different formats?

The canonical RFC 4122 format is lowercase with hyphens: 550e8400-e29b-41d4-a716-446655440000. Other common formats: uppercase with hyphens (common in .NET), no hyphens (common in some databases), and URN format (urn:uuid:550e8400-...). All represent the same 128-bit value. Use the toggles above to switch between formats.

Can I use UUIDs as API keys or authentication tokens?

UUID v4 can be used as API keys for low-security applications because its 122 bits of randomness make brute-force guessing infeasible. For production authentication, use dedicated token formats. Always transmit tokens over HTTPS and store them hashed (using SHA-256) in your database — never in plain text. Need to compute a SHA-256 hash? Use our Hash Generator.

How long is a UUID string?

A canonical UUID string is always exactly 36 characters: 32 hexadecimal digits plus 4 hyphens in the format 8-4-4-4-12. Without hyphens it is 32 characters. As a binary type it is 16 bytes (128 bits). In PostgreSQL's native UUID column, it is stored as 16 bytes but displayed as the 36-character string.