Free UUID Generator

What is a UUID?

A UUID (Universally Unique Identifier) is a 128-bit label written as 32 hexadecimal digits in five hyphen-separated groups — 8-4-4-4-12, as in 3f2504e0-4f89-41d3-9a0c-0305e82c3301. Its purpose is to let independent systems mint identifiers that will not collide, without any of them having to ask a central authority for permission.

UUIDs are defined by RFC 9562, published in May 2024, which replaced the older RFC 4122 and added versions 6, 7 and 8. Microsoft calls the same 128-bit structure a GUID (Globally Unique Identifier); the two words describe the identical format and are used interchangeably.

Of those 128 bits, 4 identify the version and 2 identify the variant, so a version 4 UUID carries 122 bits of randomness — about 5.3 × 10³⁶ possible values.

UUID versions compared

The version number is the 13th hexadecimal digit — the first character of the third group. In 3f2504e0-4f89-41d3-9a0c-0305e82c3301 that digit is a 4, so it is a version 4 UUID.

Which version should you use?

• Storing rows in a database? Use v7. Because the timestamp leads, new rows land at the right-hand edge of a B-tree index instead of scattering across it, which is the difference between a healthy index and a fragmented one.
• Just need an identifier? Use v4. It is universally supported and reveals nothing about when or where it was created.
• Need the same input to always produce the same UUID? Use v5.
• Worried about leaking timing information? Avoid v1, v6 and v7 — anyone holding one of those can read the creation time straight out of it. Use v4.

How to generate a UUID

1. Pick a version Version 4 is selected by default and is the right answer most of the time. Switch to v7 if the UUID will become a database key.
2. Read the value A UUID appears as soon as the page loads. Press Generate new UUID, or the G key, for another.
3. Adjust the formatting Toggle uppercase, hyphens, braces or quotes. Changing these reformats what is on screen without generating a new value.
4. Copy or export Press Copy or the C key. For many at once, use the Bulk tab and download as .txt, .json, .csv, .sql, .ts or .xml.

Generate a UUID in code

Most languages can do this without a dependency. Here is the shortest correct way in each.

// Browsers and Node 19+. Secure contexts only (HTTPS or localhost).
const id = crypto.randomUUID();

// Node.js, explicit import
import { randomUUID } from "node:crypto";
const id2 = randomUUID();

// Version 7, via the uuid package
import { v7 as uuidv7, v5 as uuidv5, NIL } from "uuid";
const ordered = uuidv7();
const stable  = uuidv5("example.com", uuidv5.DNS);

import uuid

uuid.uuid4()                                    # random
uuid.uuid1()                                    # timestamp + node
uuid.uuid5(uuid.NAMESPACE_DNS, "example.com")   # deterministic

# Python 3.14 and later also ship v6, v7 and v8
uuid.uuid7()

# Parsing and inspecting
u = uuid.UUID("3f2504e0-4f89-41d3-9a0c-0305e82c3301")
print(u.version, u.variant, u.hex, u.int)

import java.util.UUID;

UUID random = UUID.randomUUID();                    // version 4
UUID parsed = UUID.fromString("3f2504e0-4f89-41d3-9a0c-0305e82c3301");

// Careful: this is version 3 (MD5), not version 5.
UUID named = UUID.nameUUIDFromBytes("example.com".getBytes(UTF_8));

int version = parsed.version();
long high = parsed.getMostSignificantBits();

// Version 4
Guid id = Guid.NewGuid();
string text = id.ToString();          // 8-4-4-4-12, lowercase
string bare = id.ToString("N");       // no hyphens
string braced = id.ToString("B");     // {3f2504e0-...}

// .NET 9 and later: time-ordered version 7
Guid ordered = Guid.CreateVersion7();

Guid parsed = Guid.Parse("3f2504e0-4f89-41d3-9a0c-0305e82c3301");

import "github.com/google/uuid"

id := uuid.New()                    // v4, panics if the RNG fails
id2, err := uuid.NewRandom()        // v4, returns the error instead

v7, _ := uuid.NewV7()               // time ordered
v5 := uuid.NewSHA1(uuid.NameSpaceDNS, []byte("example.com"))

parsed, err := uuid.Parse("3f2504e0-4f89-41d3-9a0c-0305e82c3301")
fmt.Println(parsed.Version(), parsed.Variant())

// With ramsey/uuid
use Ramsey\Uuid\Uuid;

$v4 = Uuid::uuid4()->toString();
$v7 = Uuid::uuid7()->toString();
$v5 = Uuid::uuid5(Uuid::NAMESPACE_DNS, 'example.com')->toString();

// Version 4 with no dependencies at all
$data = random_bytes(16);
$data[6] = chr(ord($data[6]) & 0x0f | 0x40);   // version
$data[8] = chr(ord($data[8]) & 0x3f | 0x80);   // variant
echo vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));

// Cargo.toml: uuid = { version = "1", features = ["v4", "v5", "v7"] }
use uuid::Uuid;

let id      = Uuid::new_v4();
let ordered = Uuid::now_v7();
let stable  = Uuid::new_v5(&Uuid::NAMESPACE_DNS, b"example.com");

let parsed = Uuid::parse_str("3f2504e0-4f89-41d3-9a0c-0305e82c3301")?;
println!("{:?} {}", parsed.get_version(), parsed.hyphenated());

-- PostgreSQL 13+
SELECT gen_random_uuid();          -- version 4, no extension needed
-- PostgreSQL 18+
SELECT uuidv7();                   -- time ordered

-- MySQL 8.0+
SELECT UUID();                     -- version 1
SELECT UUID_TO_BIN(UUID(), 1);     -- swap the time bits for index locality

-- SQL Server
SELECT NEWID();                    -- version 4
SELECT NEWSEQUENTIALID();          -- only inside a DEFAULT constraint

-- Table definition
CREATE TABLE orders (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

How unique is a UUID, really?

Version 4 UUIDs carry 122 random bits, giving 2¹²² ≈ 5.3 × 10³⁶ possible values. You would need to generate roughly 2.71 × 10¹⁸ of them before reaching a 50% chance that any two matched.

A more useful way to hold it: across 103 trillion version 4 UUIDs, the probability that even one duplicate exists is about one in a billion. Put differently, generating a billion UUIDs per second, it would take around 85 years to reach even odds of a single collision.

The caveat that actually matters in practice: this only holds when the values come from a cryptographically secure random source. A generator built on Math.random() or a seeded pseudo-random number generator has far less real entropy than the bit count suggests, and duplicates become plausible. This page uses crypto.getRandomValues(), which draws from the operating system CSPRNG.

How this tool works

Every UUID on this page is produced by JavaScript running in your own browser. Nothing is sent to a server, nothing is logged, and the page keeps working with the network switched off once it has loaded.

• Randomness comes from crypto.getRandomValues(), the browser interface to the operating system CSPRNG. If a browser does not provide it, the page refuses to generate rather than falling back to something weaker.
• Version 1 and 6 normally embed the machine MAC address as the node field. This page substitutes a random node with the multicast bit set, exactly as RFC 9562 permits, so no hardware identity is exposed.
• History is held in your browser localStorage, capped at the 40 most recent values. It never leaves the device, and the Clear button removes it.
• The JSON API is the one part that involves a server. It generates with PHP random_bytes() and stores nothing.