Generate identifiers
Generate UUIDs of versions 1, 3, 4, 5, 6 and 7, or ULIDs, one at a time or in batches of up to a thousand, and analyse any identifier to learn its version, its variant and the date it carries. They are computed in your browser with the system's cryptographic generator.
122 random bits. The most common choice when you just need a unique identifier.
Format
Result
Analyse a UUID or ULID
Accepts hyphens, braces, the urn:uuid: prefix or a 26-character ULID
Type
Version 7: sortable Unix date
Variant
RFC 9562 (formerly RFC 4122)
Creation date
Feb 22, 2022, 4:22:22 PM 2022-02-22T19:22:22.000Z · 1645557742000 ms
Canonical017f22e2-79b0-7cc3-98c4-dc0c0c07398f
Uppercase017F22E2-79B0-7CC3-98C4-DC0C0C07398F
GUID with braces{017F22E2-79B0-7CC3-98C4-DC0C0C07398F}
URNurn:uuid:017f22e2-79b0-7cc3-98c4-dc0c0c07398f
As ULID01FWHE4YDGFK1SHH6W1G60EECF
Hexadecimal017f22e279b07cc398c4dc0c0c07398f
Decimal integer1989357241971137676463954034883508623
Base64AX8i4nmwfMOYxNwMDAc5jw==

How it works

A UUID is a 128-bit number written as 32 hexadecimal digits in five groups (8-4-4-4-12). It identifies a record without asking anyone whether the value is already taken: two servers, two mobile apps or two processes can create identifiers at the same time without coordinating and without colliding. The format is defined by RFC 9562, which replaced RFC 4122 in 2024 and added versions 6, 7 and 8.

The digit that opens the third group gives the version, and each version lays out the bits differently. Version 4 is pure randomness. Version 7 starts with the date in milliseconds, so identifiers end up sorted by creation. Versions 3 and 5 contain nothing random: they come from the hash of a namespace and a name, so they always give the same result. Versions 1 and 6 carry a date with 100-nanosecond precision and a node that historically was the computer's MAC address.

The analyser works the other way round: it reads the version and the variant, recovers the date of v1, v6 and v7 UUIDs and of ULIDs, and shows the same value written as a GUID, URN, hexadecimal, integer or Base64. Everything is computed in your browser; no identifier is sent to a server.

Examples

v5 · DNS · www.example.com2ed6657d-e927-568b-95e1-2665a8aea6a2This is the RFC 9562 test vector. Any library that implements version 5 correctly must return exactly this value for that name in the DNS namespace.
017F22E2-79B0-7CC3-98C4-DC0C0C07398F2022-02-22T19:22:22.000ZThe first 12 digits of a v7 UUID are the Unix milliseconds in hexadecimal: 0x017F22E279B0 is 1645557742000.
C232AB00-9414-11EC-B3C8-9F6BDECED8461EC9414C-232A-6B00-B3C8-9F6BDECED846The same instant as version 1 and as version 6. Version 6 reorders the date bits from most to least significant so the text sorts chronologically; the clock sequence and the node do not change.
01ARZ3NDEKTSV4RRFFQ69G5FAV01563e3a-b5d3-d676-4c61-efb99302bd5bA ULID takes up the same 128 bits as a UUID, so it can be stored in a uuid column. But it has no version or variant: when read as a UUID, those digits are part of the random data.

Use cases

  • Create the primary key on the client or in several services at once, without waiting for the database to assign an auto-increment.
  • Generate idempotency keys so that a retried payment or order is not processed twice.
  • Tag each request with a correlation ID to follow it through the logs of several microservices.
  • Derive with v5 a stable identifier from a natural key (an email, a URL, a SKU) so that two systems arrive at the same value without sharing a table.
  • Find out when a record was created from its v7 UUID or its ULID when it shows up in a log or an error report.
  • Load test data with hundreds of valid identifiers in one go.

Frequently asked questions

v4 or v7 for a primary key?

v7, unless you have a reason to hide the creation date. B-tree indexes store keys in order, and a v4 lands anywhere in the index: every insert touches a different page, pages split and the cache is less effective. A v7 always goes at the end, like an auto-increment. Watch out for SQL Server: the uniqueidentifier type sorts starting from the last six bytes, so a v7 is not sequential there either.

Can two v4 UUIDs repeat?

In theory yes, in practice no. A v4 has 122 random bits, and to reach a 50 % chance of at least one repeat you would have to generate about 2.7 × 10¹⁸ of them, that is, a billion per second for more than 85 years. The condition is using a cryptographic generator: the real duplicates people report come from badly seeded generators, not from the maths.

Are UUID and GUID the same thing?

Yes, GUID is the name Microsoft uses and the text is identical; on Windows it usually appears in uppercase and in braces. The difference is in the binary form: .NET's Guid.ToByteArray stores the first three groups in little-endian, so if you read those raw bytes from another language you will see the first digits reversed.

Can I use a UUID as a secret token?

A well-generated v4 has 122 unpredictable bits, which is enough for a hard-to-guess link, but RFC 9562 states that UUIDs are not meant as credentials: many libraries do not guarantee a cryptographic generator, and versions 1, 6 and 7 reveal the creation date. For session or password-reset tokens it is better to generate dedicated random bytes.

ULID or UUID v7?

They carry almost the same information: 48 bits of milliseconds and the rest random. A ULID is written in 26 characters with no hyphens or ambiguous letters, which is handier in a URL. A v7 is a standard UUID, so it fits PostgreSQL uuid columns and any validator without conversion. If you are starting from scratch and your database has a uuid type, go with v7.

Why isn't the node in my v1 UUIDs my MAC?

Because exposing the network card's MAC lets anyone trace which machine created each identifier, and that is how the author of the Melissa virus was identified in 1999. RFC 9562 recommends a random node with the multicast bit set, which is what this tool does; the analyser tells you when a v1 UUID contains a real MAC.