UUID Generator Online Free — v1, v4, v5 Explained

Most developers have used a UUID without thinking much about how it works. That's usually fine — until it isn't. Choosing the wrong version can expose your server's MAC address, break deterministic ID generation, or produce non-sortable keys that slow down your database. Let's start from the beginning.

What Is a UUID and Why Do Developers Use It?

Auto-incrementing integers are simple for single-database setups. They break immediately in distributed systems, microservices, or any scenario where two nodes write records independently. UUID v4 solves this: each node generates its own IDs with no coordination, and the collision probability is so low it's treated as zero in practice.

Common uses include:

• Database primary keys. PostgreSQL has a native UUID column type. MySQL, SQLite, and MongoDB all support UUIDs natively or as strings.
• Session IDs. A v4 UUID is long enough and random enough to serve as a secure session token without any additional entropy.
• API request tracing. Assign a UUID to every incoming request for end-to-end tracing across microservices.
• File names. Rename uploaded files to a UUID before storage to prevent path traversal attacks and name collisions.
• Tracking pixels and event IDs. Each event gets a unique, non-guessable identifier that's safe to expose publicly.

UUID Versions Explained: v1, v4, and v5

UUID v1 — Timestamp + MAC address

Version 1 builds the UUID from the current timestamp (100-nanosecond intervals since October 15, 1582) combined with the generating node's MAC address. This makes v1 UUIDs sortable by generation time. It also means they're not random: two UUIDs generated on the same machine a few milliseconds apart are very similar, and anyone with the UUID can extract the generation time and a fingerprint of the source machine.

UUID v4 — Cryptographically random

Version 4 sets 6 bits to fixed version/variant markers and fills the remaining 122 bits with random data. That's 2^122, or about 5.3 x 10^36, possible values. There's no timestamp, no MAC address, no structured data at all. It's the right default for almost every application. The only downside is that v4 UUIDs aren't sortable, which matters for certain database indexing strategies.

UUID v5 — SHA-1 hash of namespace + name

Version 5 takes a namespace UUID and a name string, runs them through SHA-1, and maps the result into UUID format. The same namespace and name always produce the same UUID. This is deterministic ID generation: useful when you need to generate a consistent ID for a known entity without storing a lookup table. A common pattern is generating a stable UUID for a URL, email address, or product SKU.

How to Generate a UUID Online Free (3 Steps)

How Does UUID v4 Randomness Work in the Browser?

Here's what happens under the hood when a browser generates a v4 UUID:

1. The browser requests 16 random bytes from crypto.getRandomValues()
2. Bits 12-15 of byte 6 are set to 0100 (version 4)
3. Bits 6-7 of byte 8 are set to 10 (RFC 4122 variant)
4. The 16 bytes are formatted as 32 hex characters with hyphens at positions 8, 12, 16, and 20

Only 6 bits are fixed. The remaining 122 bits are pure random data from the OS entropy pool. This means browser-generated v4 UUIDs are safe to use as session tokens or API keys, provided you use the full 36-character string and don't truncate it.

UUID vs. ULID vs. CUID vs. NanoID — Which Should You Use?

UUID v4 wins on compatibility: every major database, ORM, and language has native UUID support. ULID wins on sortability and URL-safety. NanoID wins on compactness. In our experience, UUID v4 is the right default unless you have a specific reason to choose otherwise — don't optimize prematurely for index locality.

What Are the Most Practical UUID Use Cases?

Database primary keys in PostgreSQL

Define a UUID column with gen_random_uuid() as the default to auto-generate v4 UUIDs at insert time. This function, available since PostgreSQL 13, draws from the same OS entropy pool as crypto.getRandomValues() in browsers. No extension required.

-- PostgreSQL: UUID primary key with auto-generation
CREATE TABLE orders (
  id        UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id   UUID NOT NULL,
  created   TIMESTAMPTZ DEFAULT NOW()
);

API endpoints and request tracing

Assign a UUID to every API request at the gateway level. Log it in every downstream service. When something breaks, search your log aggregator for that UUID and you get the complete trace across every service, with no coordination between teams needed.

File names for uploads

Never store uploaded files under their original names. A UUID filename prevents directory traversal attacks, collision between users who upload a file with the same name, and exposure of internal naming conventions. The original filename goes in a database column; the UUID goes in your object store.

Idempotency keys for payment APIs

Stripe, Braintree, and most payment processors accept an idempotency key with each request. Generate a v4 UUID before sending the request, store it locally, and retry with the same key if the network fails. The server guarantees the same response for the same key, preventing double-charges.

How Do You Generate a UUID in JavaScript, Python, and Go?

JavaScript (browser and Node.js)

// Browser or Node.js 15+ — no library needed
const id = crypto.randomUUID();
// "110e8400-e29b-41d4-a716-446655440000"

// Node.js < 15 or older browsers: use the 'uuid' package
import { v4 as uuidv4 } from 'uuid';
const id = uuidv4();

// UUID v5 (deterministic — same input = same output)
import { v5 as uuidv5 } from 'uuid';
const MY_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
const id = uuidv5('https://example.com/page', MY_NAMESPACE);

Python

import uuid

# UUID v4 (random) — most common
id_v4 = uuid.uuid4()
print(str(id_v4))  # "550e8400-e29b-41d4-a716-446655440000"

# UUID v5 (deterministic)
id_v5 = uuid.uuid5(uuid.NAMESPACE_URL, 'https://example.com')
print(str(id_v5))

# UUID v1 (timestamp + MAC — use only in closed internal systems)
id_v1 = uuid.uuid1()
print(str(id_v1))

Go

// go get github.com/google/uuid
package main

import (
    "fmt"
    "github.com/google/uuid"
)

func main() {
    // UUID v4
    id, _ := uuid.NewRandom()
    fmt.Println(id.String())

    // UUID v5 (deterministic)
    ns := uuid.NameSpaceURL
    id5 := uuid.NewSHA1(ns, []byte("https://example.com"))
    fmt.Println(id5.String())
}