GUID Generator

Supported formatting options

All of these carry the same 128 bits. Only the presentation differs, and which one you want is decided by whatever has to read it.

What is a GUID?

“GUID” and “UUID” name the same thing. The format is specified in RFC 9562, which obsoleted RFC 4122 in 2024, and identically in ITU-T X.667 — the two bodies publish a common text, so a UUID is valid under either.

A GUID (Globally Unique Identifier) is a 128-bit value written as 32 hexadecimal digits, conventionally grouped as 8-4-4-4-12 and separated by hyphens. UUID (Universally Unique Identifier) is the same thing under a different name — Microsoft popularized "GUID", the IETF standard says "UUID", and in practice the terms are interchangeable.

The point of a GUID is that you can generate one anywhere, at any time, without asking a central authority whether it is taken. Two developers on opposite sides of the world, both offline, can each create identifiers and the values will not collide. That property is what makes GUIDs so useful in distributed systems, where a shared auto-incrementing counter would be a bottleneck or a single point of failure.

How unique is "Unique"?

GUIDs are not guaranteed unique in a mathematical sense — they are drawn from a space so large that collisions are not a practical concern. A version 4 UUID has 122 random bits, which is about 5.3 × 10³⁶ possible values.

To put that in perspective: you would need to generate roughly 2.6 × 10¹⁸ GUIDs before the chance of a single collision reached 50%. At a billion GUIDs per second, that would take about 85 years. For any realistic application, treating them as unique is entirely safe.

Choosing a version

This tool can produce three versions. Version 4 — the random variety, and by far the most commonly used — is the right default when you simply need an identifier with no structure and no leaked information. Version 7 embeds a millisecond timestamp in the leading bits, so identifiers sort chronologically; that ordering keeps newly-inserted rows adjacent in a database index instead of scattering writes across it, which is why it is increasingly preferred for primary keys. Version 1 embeds a timestamp and a node identifier — traditionally the machine's MAC address — and is offered mainly for interop with older systems that expect it; this tool fills the node field with random bits rather than a real MAC address, so nothing about your hardware is exposed.

Randomness comes from your browser's cryptographically secure generator, not a general-purpose one. This matters more than it sounds: a predictable generator would let someone guess identifiers they were never given, which is a genuine security problem if a GUID acts as an unguessable URL for a shared document or a password reset.

Formatting options

The same 128-bit value gets written differently across ecosystems, which is why the options above exist:

• Hyphens— the standard 8-4-4-4-12 grouping. Removing them gives a compact 32 character string, common in URLs and database columns.
• Braces— the registry and COM convention on Windows, and what.NET produces with the "B" format specifier.
• Uppercase— the standard says lowercase, but plenty of Microsoft tooling emits uppercase and some systems compare case-sensitively.
• Quotes and commas— generate a list you can paste straight into an array literal, a CSV column, or a SQL IN clause.
• URN prefix— the urn:uuid: form defined by RFC 4122, used where a UUID must be expressed as a formal URI.

Common uses

• Database primary keys— lets clients create records offline and sync later, and avoids exposing row counts the way sequential IDs do.
• Distributed systems— every service can mint identifiers independently with no coordination.
• Idempotency keys— attach one to a payment or API request so a retry cannot be processed twice.
• Correlation IDs— tag a request at the edge and trace it across every service and log line it touches.
• File and object names— avoid collisions in shared storage without coordinating names.
• Test fixtures— generate throwaway identifiers that will not clash with real data.

Trade-offs worth knowing

GUIDs are not free. At 16 bytes they are four times the size of a 32-bit integer, and as text they occupy 36 characters. In a database, random keys scatter inserts across the index rather than appending to the end, which can hurt write performance and cache locality on large tables. They are also awkward for people — nobody reads a GUID over the phone.

Where those costs matter, common approaches are a sequential primary key paired with a GUID as the externally visible identifier, or a time-ordered UUID variant that preserves insert locality.