Generate UUID in Go

UUID v4 - Random (recommended default)

import "github.com/google/uuid"

// Returns uuid.UUID ([16]byte) - value type, no heap allocation
id := uuid.New()
fmt.Println(id.String()) // → "550e8400-e29b-41d4-a716-446655440000"

// Or get a string directly
idStr := uuid.NewString()

UUID v7 - Time-ordered (database PKs)

import "github.com/google/uuid"

// Millisecond-precision timestamp prefix - sorts chronologically
id, err := uuid.NewV7()
if err != nil {
    log.Fatal(err)
}
fmt.Println(id.String()) // → "018e8f6a-1b2c-7d3e-9f4a-5b6c7d8e9f0a"

UUID v5 - Deterministic / Namespace-based

import "github.com/google/uuid"

// SHA-1 hash of namespace + name - same inputs always produce the same UUID
id := uuid.NewSHA1(uuid.NameSpaceDNS, []byte("example.com"))
fmt.Println(id.String()) // → always "cfbff0d1-9375-5685-968c-48ce8b15ae17"

1. gRPC interceptor - request tracing ID

import (
    "context"
    "github.com/google/uuid"
    "google.golang.org/grpc"
)

func UnaryRequestIDInterceptor(
    ctx context.Context,
    req interface{},
    info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler,
) (interface{}, error) {
    requestID := uuid.NewString()
    ctx = context.WithValue(ctx, "requestID", requestID)
    return handler(ctx, req)
}

2. GORM model with UUID primary key

import (
    "github.com/google/uuid"
    "gorm.io/gorm"
)

type Order struct {
    ID        uuid.UUID `gorm:"type:uuid;primaryKey"`
    CreatedAt time.Time
    Name      string
}

// Auto-assign UUID before create
func (o *Order) BeforeCreate(tx *gorm.DB) error {
    o.ID = uuid.New()
    return nil
}

3. Distributed tracing - correlation ID

import (
    "net/http"
    "github.com/google/uuid"
)

func RequestIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        requestID := uuid.NewString()
        w.Header().Set("X-Request-ID", requestID)
        ctx := context.WithValue(r.Context(), "requestID", requestID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

How do I generate a UUID in Go?

Go has no UUID type in its standard library. The community standard is the github.com/google/uuid package: run go get github.com/google/uuid, then call uuid.New() for a random v4 UUID or uuid.NewV7() for a time-ordered v7. Both read entropy from crypto/rand.

Is uuid.New() cryptographically secure?

Yes. uuid.New() 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 Go?

UUID v4 (uuid.New() 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 Go?

A package or library install may be required. See the Installation section for the recommended approach in Go.

How do I validate a UUID string in Go?

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 Go 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 Go 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 Go?

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 Go 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.New() or equivalent) unless you need legacy Cassandra timeuuid compatibility.