Generate UUID in Python

UUID v4 - Random (recommended default)

import uuid
# 122 bits of randomness - use for anything that just needs a unique ID
id = uuid.uuid4()
print(str(id))  # → "550e8400-e29b-41d4-a716-446655440000"

UUID v5 - Deterministic / Namespace-based

import uuid
# SHA-1 hash of namespace + name - same inputs always produce the same UUID
# Useful for deduplication and content-addressable IDs
id = uuid.uuid5(uuid.NAMESPACE_DNS, "example.com")
print(str(id))  # → always "cfbff0d1-9375-5685-968c-48ce8b15ae17"

# Custom namespace
my_ns = uuid.uuid4()  # generate once, store it
record_id = uuid.uuid5(my_ns, "user:42")

UUID v1 - Timestamp + MAC (legacy)

import uuid
# Encodes current timestamp + MAC address - sortable but leaks host info
# Only use for Cassandra timeuuid or legacy system compatibility
id = uuid.uuid1()
print(id.time)  # 100-nanosecond intervals since Oct 15, 1582

1. Django / SQLAlchemy model primary key

import uuid
from django.db import models

class Order(models.Model):
    # Django natively supports UUIDField
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    created_at = models.DateTimeField(auto_now_add=True)

# SQLAlchemy equivalent
from sqlalchemy import Column, String
from sqlalchemy.dialects.postgresql import UUID as PG_UUID

class Product(Base):
    __tablename__ = "products"
    id = Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)

2. FastAPI request tracing

import uuid
from fastapi import FastAPI, Request
import logging

app = FastAPI()
logger = logging.getLogger(__name__)

@app.middleware("http")
async def add_request_id(request: Request, call_next):
    request_id = str(uuid.uuid4())
    request.state.request_id = request_id
    response = await call_next(request)
    response.headers["X-Request-ID"] = request_id
    logger.info(f"[{request_id}] {request.method} {request.url.path}")
    return response

3. Deduplication with UUID v5

import uuid

# Idempotent event ID - same event always gets the same UUID
EVENT_NAMESPACE = uuid.UUID("6ba7b810-9dad-11d1-80b4-00c04fd430c8")

def event_id(source: str, event_type: str, timestamp: str) -> str:
    key = f"{source}:{event_type}:{timestamp}"
    return str(uuid.uuid5(EVENT_NAMESPACE, key))

# Calling twice with same args returns the same UUID - safe to retry
id1 = event_id("payments", "charge.created", "2026-05-01T12:00:00Z")
id2 = event_id("payments", "charge.created", "2026-05-01T12:00:00Z")
assert id1 == id2  # True

How do I generate a UUID in Python?

Python ships a uuid module in its standard library, so there is nothing to install. uuid.uuid4() returns a random v4 UUID and str() gives the canonical form. Python 3 has no built-in v7, so use a package such as uuid6 or uuid-utils for time-ordered UUIDs.

Is uuid.uuid4() cryptographically secure?

Yes. uuid.uuid4() uses the platform CSPRNG (operating system secure random source), suitable for session tokens, API keys, and idempotency keys. Do not use non-cryptographic random sources for security-sensitive identifiers.

What is the difference between UUID v4 and v7 in Python?

UUID v4 (uuid.uuid4() or equivalent) is fully random and not sortable. UUID v7 embeds a millisecond timestamp for chronological sorting (RFC 9562). Use v4 for general-purpose IDs; use v7 for database primary keys at scale.

Do I need to install a package for UUID generation in Python?

No additional package is required for basic v4 generation in Python. Check the Installation section for version-specific notes.

How do I validate a UUID string in Python?

Use the platform's UUID parse/validation function, or test against the RFC 4122 regex: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i. Always validate external input at API boundaries.

Should I use UUIDs as database primary keys in Python applications?

UUIDs work well as primary keys for distributed systems. Prefer native UUID/BINARY(16) column types over VARCHAR(36). For very large tables, consider UUID v7 for better B-tree insert locality.

Can I generate UUIDs in Python without a network connection?

Yes. UUID generation uses local OS entropy sources and does not require network access. Each call is independent and thread-safe on modern platforms.

What output formats are available in Python?

The standard hyphenated lowercase string (36 chars) is the default. Most APIs also support 32-char hex (no hyphens) and 16-byte binary formats. Use string format for APIs and binary for database storage.

What RFC standards apply to Python UUID generation?

Version 4 UUIDs follow RFC 4122. UUID v7 follows RFC 9562 (May 2024). Ensure your chosen method produces compliant version and variant bits.

When should I avoid UUID v1?

Avoid UUID v1 in security-sensitive contexts - it embeds MAC address and timestamp information. Prefer v4 (uuid.uuid4() or equivalent) unless you need legacy Cassandra timeuuid compatibility.