Free Online UUID Generator (v4)

History and Development

UUIDs were first standardized in 1990 by the Open Software Foundation (OSF) as part of the Distributed Computing Environment (DCE). Version 4, introduced later, uses random or pseudo-random numbers to generate identifiers, making it the most commonly used version today. The specification was later published as an Internet Engineering Task Force (IETF) standard in RFC 4122.

Structure and Format

A UUIDv4 consists of 32 hexadecimal digits, displayed in five groups separated by hyphens. The structure follows the pattern: 8-4-4-4-12 characters. The version number (4) is encoded in the 13th character, and the variant is encoded in the 17th character. The rest of the bits are randomly generated, making each UUIDv4 unique.

Example UUIDv4: 123e4567-e89b-12d3-a456-426614174000

Breakdown:
- First group (8 chars): 123e4567
- Second group (4 chars): e89b
- Third group (4 chars): 12d3
- Fourth group (4 chars): a456
- Fifth group (12 chars): 426614174000

Common Applications

• Database primary keys and unique identifiers
• Session management in web applications
• File naming and version control systems
• Distributed systems and microservices
• API request tracking and logging
• Message queue identifiers
• Document versioning
• Transaction tracking

Implementation Details

Modern implementations of UUIDv4 typically use cryptographically secure random number generators (CSPRNGs) to ensure uniqueness and security. In web browsers, the Web Crypto API provides this functionality. In Node.js, the crypto module is commonly used, while in Python, the uuid module uses the system's random number generator.

Security Considerations

Fun Facts

Best Practices

Frequently Asked Questions

Database Integration

-- Enable UUID extension
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

-- Create a table with UUID primary key
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    name VARCHAR(100)
);

-- Insert a record with auto-generated UUID
INSERT INTO users (name) VALUES ('John Doe');

-- Query using UUID
SELECT * FROM users WHERE id = '123e4567-e89b-12d3-a456-426614174000';

-- Create a table with UUID primary key
CREATE TABLE users (
    id CHAR(36) PRIMARY KEY,
    name VARCHAR(100)
);

-- Insert a record with UUID
INSERT INTO users (id, name) VALUES (UUID(), 'John Doe');

-- Query using UUID
SELECT * FROM users WHERE id = '123e4567-e89b-12d3-a456-426614174000';

// MongoDB with Node.js
const { MongoClient } = require('mongodb');
const { v4: uuidv4 } = require('uuid');

async function insertDocument() {
    const client = new MongoClient('mongodb://localhost:27017');
    await client.connect();
    
    const db = client.db('mydb');
    const collection = db.collection('documents');
    
    const doc = {
        _id: uuidv4(),
        createdAt: new Date(),
        type: 'user_action',
        data: {
            userId: uuidv4()
        }
    };
    
    await collection.insertOne(doc);
    await client.close();
}

UUID vs GUID

// JavaScript/Node.js (UUID)
const uuid = require('uuid');
const id = uuid.v4();

// C# (.NET) (GUID)
Guid guid = Guid.NewGuid();

// SQL Server (GUID)
DECLARE @guid UNIQUEIDENTIFIER = NEWID();

// PostgreSQL (UUID)
SELECT uuid_generate_v4();

UUID Versions

Advanced Database Integration

-- Create a table with UUID and timestamps
CREATE TABLE events (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    event_type VARCHAR(50),
    data JSONB
);

-- Create an index on UUID
CREATE INDEX idx_events_id ON events(id);

-- Query with UUID range (for UUIDv1)
SELECT * FROM events 
WHERE id >= '00000000-0000-1000-8000-000000000000'
AND id < '00000000-0000-2000-8000-000000000000';

-- Bulk insert with UUIDs
INSERT INTO events (event_type, data)
SELECT 
    'user_action',
    jsonb_build_object('user_id', uuid_generate_v4())
FROM generate_series(1, 1000);

-- Create a table with UUID and timestamps
CREATE TABLE events (
    id CHAR(36) PRIMARY KEY,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    event_type VARCHAR(50),
    data JSON
);

-- Create an index on UUID
CREATE INDEX idx_events_id ON events(id);

-- Query with UUID range
SELECT * FROM events 
WHERE id BETWEEN '00000000-0000-1000-8000-000000000000'
AND '00000000-0000-2000-8000-000000000000';

-- Bulk insert with UUIDs
INSERT INTO events (id, event_type, data)
SELECT 
    UUID(),
    'user_action',
    JSON_OBJECT('user_id', UUID())
FROM (SELECT 1 UNION SELECT 2 UNION SELECT 3) AS numbers;

// MongoDB with Node.js
const { MongoClient } = require('mongodb');
const { v4: uuidv4 } = require('uuid');

async function insertDocument() {
    const client = new MongoClient('mongodb://localhost:27017');
    await client.connect();
    
    const db = client.db('mydb');
    const collection = db.collection('documents');
    
    const doc = {
        _id: uuidv4(),
        createdAt: new Date(),
        type: 'user_action',
        data: {
            userId: uuidv4()
        }
    };
    
    await collection.insertOne(doc);
    await client.close();
}

Language-Specific Examples

// TypeScript implementation
import { v4 as uuidv4 } from 'uuid';

interface User {
    id: string;
    name: string;
    createdAt: Date;
}

function createUser(name: string): User {
    return {
        id: uuidv4(),
        name,
        createdAt: new Date()
    };
}

// Using with Express
import express from 'express';
const app = express();

app.post('/users', (req, res) => {
    const user = createUser(req.body.name);
    // Save to database...
    res.json(user);
});

# Python implementation with FastAPI
from fastapi import FastAPI
from pydantic import BaseModel
from uuid import uuid4
from datetime import datetime

app = FastAPI()

class User(BaseModel):
    id: str
    name: str
    created_at: datetime

@app.post("/users")
async def create_user(name: str):
    user = User(
        id=str(uuid4()),
        name=name,
        created_at=datetime.now()
    )
    // Save to database...
    return user

// Go implementation with Gin
package main

import (
    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
    "time"
)

type User struct {
    ID        string    `json:"id"`
    Name      string    `json:"name"`
    CreatedAt time.Time `json:"created_at"`
}

func main() {
    r := gin.Default()
    
    r.POST("/users", func(c *gin.Context) {
        user := User{
            ID:        uuid.New().String(),
            Name:      c.PostForm("name"),
            CreatedAt: time.Now(),
        }
        // Save to database...
        c.JSON(200, user)
    })
    
    r.Run()
}

// Java implementation
import java.security.SecureRandom;
import java.util.UUID;

public class UUIDGenerator {
    public static String generateUUIDv4() {
        // Using Java's built-in UUID class
        return UUID.randomUUID().toString();
    }

    // Alternative implementation using SecureRandom
    public static String generateUUIDv4Manually() {
        SecureRandom random = new SecureRandom();
        byte[] bytes = new byte[16];
        random.nextBytes(bytes);
        
        // Set version (4) and variant bits
        bytes[6] &= 0x0f;  // Clear version
        bytes[6] |= 0x40;  // Set version to 4
        bytes[8] &= 0x3f;  // Clear variant
        bytes[8] |= 0x80;  // Set variant to RFC 4122
        
        return String.format("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
            bytes[0], bytes[1], bytes[2], bytes[3],
            bytes[4], bytes[5], bytes[6], bytes[7],
            bytes[8], bytes[9], bytes[10], bytes[11],
            bytes[12], bytes[13], bytes[14], bytes[15]);
    }
}

JavaScript/Node.js Implementation

This implementation uses Node.js's crypto module to generate cryptographically secure random numbers. It follows the UUIDv4 specification by setting the version and variant bits appropriately.

// JavaScript/Node.js implementation
const crypto = require('crypto');

function generateUUIDv4() {
  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
  );
}

Go Implementation

The Go implementation uses the crypto/rand package to generate secure random numbers. It manually constructs the UUID by setting the version and variant bits according to the UUIDv4 specification.

// Go implementation
package main

import (
    "crypto/rand"
    "fmt"
    "io"
)

func generateUUIDv4() string {
    uuid := make([]byte, 16)
    n, err := io.ReadFull(rand.Reader, uuid)
    if n != len(uuid) || err != nil {
        panic(err)
    }
    
    // Set version (4) and variant bits
    uuid[6] = (uuid[6] & 0x0f) | 0x40
    uuid[8] = (uuid[8] & 0x3f) | 0x80
    
    return fmt.Sprintf("%x-%x-%x-%x-%x",
        uuid[0:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:])
}

Java Implementation

Java provides two approaches shown here: one using the built-in UUID class and another manual implementation using SecureRandom. Both methods ensure cryptographically secure UUID generation.

// Java implementation
import java.security.SecureRandom;
import java.util.UUID;

public class UUIDGenerator {
    public static String generateUUIDv4() {
        // Using Java's built-in UUID class
        return UUID.randomUUID().toString();
    }

    // Alternative implementation using SecureRandom
    public static String generateUUIDv4Manually() {
        SecureRandom random = new SecureRandom();
        byte[] bytes = new byte[16];
        random.nextBytes(bytes);
        
        // Set version (4) and variant bits
        bytes[6] &= 0x0f;  // Clear version
        bytes[6] |= 0x40;  // Set version to 4
        bytes[8] &= 0x3f;  // Clear variant
        bytes[8] |= 0x80;  // Set variant to RFC 4122
        
        return String.format("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
            bytes[0], bytes[1], bytes[2], bytes[3],
            bytes[4], bytes[5], bytes[6], bytes[7],
            bytes[8], bytes[9], bytes[10], bytes[11],
            bytes[12], bytes[13], bytes[14], bytes[15]);
    }
}

Python Implementation

Python offers both a simple solution using the built-in uuid module and a more detailed implementation using os.urandom. Both methods provide secure UUID generation following the UUIDv4 specification.

# Python implementation
import uuid

def generate_uuidv4():
    # Using Python's built-in uuid module
    return str(uuid.uuid4())

# Alternative implementation using os.urandom
import os

def generate_uuidv4_manually():
    # Generate 16 random bytes
    random_bytes = os.urandom(16)
    
    # Convert to bytearray for manipulation
    uuid_bytes = bytearray(random_bytes)
    
    # Set version (4) and variant bits
    uuid_bytes[6] = (uuid_bytes[6] & 0x0f) | 0x40  # Set version to 4
    uuid_bytes[8] = (uuid_bytes[8] & 0x3f) | 0x80  # Set variant to RFC 4122
    
    # Format as UUID string
    return f"{uuid_bytes[0:4].hex()}-{uuid_bytes[4:6].hex()}-{uuid_bytes[6:8].hex()}-{uuid_bytes[8:10].hex()}-{uuid_bytes[10:16].hex()}"