UUID v4 Generator & GUID Guide

A UUID (Universally Unique Identifier), also called a GUID in Microsoft ecosystems, is a 128-bit value standardized under RFC 4122 for identifying records without a central coordinating authority. The point of a UUID is that two independent systems — a mobile client generating an offline record, a backend service assigning an order ID — can each mint identifiers with a negligible chance of ever colliding, without ever talking to each other first. The most common variant, UUIDv4, dedicates 122 of its 128 bits to randomness, with the remaining 6 bits fixed to mark the version (4) and variant per the spec. Formatted as five hyphen-separated groups of hex digits (8-4-4-4-12), a v4 UUID looks like f47ac10b-58cc-4372-a567-0e02b2c3d479. Other RFC 4122 versions exist for different use cases: v1 encodes a timestamp and MAC address (leaking machine identity, now largely avoided), and v5 derives a deterministic UUID from a namespace and name using SHA-1, useful when you need the same input to always produce the same identifier.

[!TIP] Need unique identifiers for records, tests, or seed data? Try our free, local UUID Generator to batch-generate RFC 4122 v4 UUIDs completely offline.

Why 122 Bits Is Practically Collision-Free

With 122 random bits, the number of possible UUIDv4 values is roughly 5.3 × 10^36. The commonly cited approximation is that you'd need to generate around a billion UUIDs per second for about 85 years before the probability of a single collision reaches 50% — a workload no realistic system approaches. This is why UUIDv4 is trusted as a primary key or distributed identifier without any coordination between the systems generating them.

Formatting Variations You'll Actually Encounter

Different languages, databases, and APIs expect slightly different textual representations of the same 128-bit value:

Standard:      f47ac10b-58cc-4372-a567-0e02b2c3d479
Uppercase:     F47AC10B-58CC-4372-A567-0E02B2C3D479
No hyphens:    f47ac10b58cc4372a5670e02b2c3d479
Braced (GUID): {f47ac10b-58cc-4372-a567-0e02b2c3d479}

Braced form is a Windows/COM convention still expected by some .NET APIs and registry-style tooling.
No-hyphens form is common when storing UUIDs as fixed-length CHAR(32) columns instead of native UUID types.
Case rarely matters for parsing, but consistency matters for string comparisons and log-diffing.

The Tradeoff Nobody Mentions: Index Fragmentation

UUIDv4's pure randomness is a double-edged sword. It's excellent for avoiding coordination between independent systems, but as a database primary key it means every insert lands at a random position in a B-tree index rather than appending to the end, which causes more page splits and worse cache locality than a sequential or time-ordered key would. For high-throughput systems where insert performance matters, this is exactly the tradeoff that has pushed some teams toward sortable alternatives (like ULIDs) that keep UUID-style decentralized uniqueness while restoring rough chronological ordering. For most applications, though, UUIDv4's simplicity and universal library support outweigh that cost.

Generating in Batches

For seeding test fixtures or populating mock data, generating UUIDs one at a time in a REPL is slow. A batch generator that produces dozens or hundreds of values at once, each drawn independently from a CSPRNG, saves the repetitive round-trip and lets you paste a ready-made block directly into a seed script or fixture file.

When to Reach for v5 Instead

Occasionally you need the same logical entity to always produce the same UUID — for example, deriving a stable identifier for an external record (like a legacy customer ID or a URL) without a lookup table. That's what UUIDv5 is for: it hashes a namespace UUID together with a name string using SHA-1, so the same namespace-plus-name pair deterministically produces the same UUID every time, anywhere. It trades randomness for reproducibility, which v4 can't offer.

Conclusion

UUIDv4 remains the practical default for random, decentralized unique identifiers precisely because its collision probability is vanishingly small without requiring any coordination logic. Knowing the formatting conventions your specific stack expects — hyphenated, braced, or bare — saves a round of find-and-replace later.