Skip to main content
L
Loopaloo
Buy Us a Coffee
All ToolsImage ProcessingAudio ProcessingVideo ProcessingDocument & TextPDF ToolsCSV & Data AnalysisConverters & EncodersWeb ToolsMath & ScienceGames
Guides & BlogAboutContact
Buy Us a Coffee
L
Loopaloo

Free online tools for developers, designers, and content creators. Your files are processed in your browser and are never uploaded - no accounts required. A few network utilities (like What's My IP and Currency Converter) call public APIs to do their job and say so on their pages.

support@loopaloo.com

Tool Categories

  • Image Tools
  • Audio Tools
  • Video Tools
  • Document & Text
  • PDF Tools
  • CSV & Data
  • Converters
  • Web Tools
  • Math & Science
  • Games

Company

  • About Us
  • Contact
  • Blog
  • FAQ

Legal

  • Privacy Policy
  • Terms of Service
  • Disclaimer

Support

Buy Us a Coffee

© 2026 Loopaloo. All rights reserved. Built with privacy in mind.

Privacy|Terms|Disclaimer
  1. Home
  2. Converters & Encoders
  3. UUID Generator
Add to favorites

UUID Generator

Generate UUID v1, v3, v4, v5, v6 and v7, ULID, NanoID, CUID2 and Snowflake IDs, and read any of them back

Runs locally in your browserMore converters & encodersJump to full guide

Related reading

  • How Computers Generate Random Numbers (and When It Matters)10 min read
  • UUIDs Explained: Universally Unique Identifiers and When to Use Them10 min read

Initializing in your browser…

You might also like

QR Code Generator

Generate QR codes and check each one scans by decoding it back before you download it

Barcode Generator

Generate linear barcodes with the quiet zone each standard requires, and read the bars back to check they are right

Color Palette Generator

Build a colour harmony that holds its lightness by rotating hue in OKLCH, with the contrast of every pair, a perceptually even tint and shade ramp, and what a colour blind reader sees

An example conversion

These are your primary keys, so they have to be unique, and you would rather they did not scatter every insert across the index.

Settings

UUID v7, four of them, all made in the same millisecond
What UUID Generator produces

Generated

0198f199-1c00-7000-b525-06d2bc608d92
0198f199-1c00-7001-a8ec-e27b2fd07f29
0198f199-1c00-7002-b9de-b87197400f7b
0198f199-1c00-7003-aee6-3220a9e5145d

The first twelve hex digits, 0198f199-1c00, are the Unix millisecond, identical across all four because they were made in the same one, so these sort by time as plain strings. The `7` after that is the version. The three digits following it run 000, 001, 002, 003: a counter that increments while the clock has not moved, which is what keeps identifiers made inside one millisecond in the order they were made. Without it a batch like this sorts arbitrarily, which defeats the point of choosing a time-ordered version at all. The `b` and `a` starting the fourth group are the variant bits, and everything after them comes from `crypto.getRandomValues`. The tool also generates v1, v3, v4, v5, v6, ULID, NanoID, CUID2 and Snowflake, and reads any of them back, including the timestamp inside a v1, v6, v7, ULID or Snowflake.

What this converter does

Generate identifiers in ten formats and read any of them back: UUID v1, v3, v4, v5, v6 and v7 from RFC 9562, plus ULID, NanoID, CUID2 and Twitter-style Snowflake. Pick a format, set a count, and every value is produced from `crypto.getRandomValues`, the platform’s cryptographic generator. The Inspect mode takes any identifier you paste, works out what it is, and takes it apart: the version, the variant, the timestamp inside a v1, v6, v7, ULID or Snowflake, and the sixteen octets with the version and variant bytes marked.

How it works

Everything is read and written on the sixteen octets rather than on the hyphenated string. That sounds like an implementation detail and is not: reading a version by taking character 14 and a variant by taking character 19 works only for one exact spelling, and the string positions are one off from the octet boundaries in a way that is easy to get wrong. Working on the octets is also what lets the tool accept a UUID in braces, with a urn:uuid: prefix, in upper case, or with the hyphens missing, and still say what it is.

RFC 9562 defines seven versions and this tool generates six of them, leaving out v2, which is a DCE security variant almost nobody uses. Which one you want depends on one question: does the order matter? A v4 is 122 random bits and sorts arbitrarily, which is fine for a value nothing indexes. A v7 puts the Unix millisecond in the first 48 bits, so a batch sorts by time as plain strings, which keeps database inserts at the end of an index instead of scattered through it. A v6 does the same job by reordering v1’s time fields; a plain v1 does not sort, because its string starts with the low 32 bits of the clock, which wrap every 429.5 seconds, and the tool says so next to each format rather than lumping them together as "time based".

The time-ordered versions are monotonic within a millisecond, which is the part that is usually missing. A generator that redraws its random field every call produces values that are unique but land in an arbitrary order when several are made in the same millisecond, and that is exactly the case a time-ordered identifier exists to handle. Here v7 carries a counter in its rand_a field, the way RFC 9562 section 6.2 method 1 describes; v1 and v6 keep a stable clock sequence and node; ULID increments its previous random field, which its own specification calls the monotonic factory; and Snowflake moves its timestamp on when the 12-bit sequence fills, rather than reusing a sequence number. Four thousand v7 made in one millisecond come out unique and in order, and the panel says on screen whether the batch you are looking at sorts in the order it was made.

v3 and v5 are the deterministic ones: MD5 or SHA-1 over a namespace UUID followed by a name, so the same input always gives the same UUID and nothing has to be stored to look it up again. Pick one of the four namespaces RFC 9562 defines (DNS, URL, OID, X.500) and type a name. These are checked against digests computed independently: v5 of "www.example.com" in the DNS namespace is 2ed6657d-e927-568b-95e1-2665a8aea6a2 and v3 of the same is 5df41881-3aed-3515-88a7-2f4a814cf09e, and the tool produces both.

There is a chi-square test built in, which draws twenty thousand identifiers and checks that every character occurs equally often, reporting the statistic against the published 0.01 critical value. It is honest about what that proves: a chi-square cannot tell a cryptographic generator from `Math.random`, which passes it comfortably and is still guessable from a handful of outputs. The source is therefore stated separately, because it is the part that actually matters.

A v1 also carries a node identifier. When that node is not a real network address, RFC 9562 section 5.1 requires the multicast bit of its first octet to be set, so a generated node can never collide with a hardware one; the generator here sets it and keeps the same node for the life of the page, because a v1 is meant to be ordered by time and node and one that changes every call is not.

How to use

  1. 1Pick a format. The line underneath says what it is, which specification defines it, whether it sorts by time, and how many identifiers it takes before a collision becomes likely.
  2. 2Set a count, and for v3 or v5 pick a namespace and type a name.
  3. 3Read the note above the list saying whether this batch sorts in the order it was made.
  4. 4Copy one, copy them all, or download the batch as a text file.
  5. 5Press Run chi-square test to draw a large sample and check the character distribution.
  6. 6Switch to Inspect and paste any identifier to see its version, variant, timestamp and raw octets.

Key features

  • Ten formats: UUID v1, v3, v4, v5, v6 and v7, plus ULID, NanoID, CUID2 and Snowflake
  • All random bits from crypto.getRandomValues, the platform cryptographic generator
  • v1, v6, v7, ULID and Snowflake are monotonic within a millisecond, so a batch sorts in the order it was made
  • The panel states whether the batch on screen actually sorts in generation order
  • v3 and v5 name based over the four RFC 9562 namespaces, checked against independently computed MD5 and SHA-1 digests
  • A built-in chi-square test against the published 0.01 critical value, with an honest note on what it does not prove
  • Inspect reads UUID v1 through v8, the nil and max UUIDs, ULID, Snowflake, NanoID and CUID2
  • Accepts a UUID in braces, as a urn, in upper case, or with no hyphens, and gives the canonical form back
  • Shows the sixteen octets with the version and variant bytes marked
  • Prefix, suffix, uppercase and no-hyphens formatting, adjustable NanoID length, up to 1,000 at a time
  • Runs entirely in the browser, and an identifier you paste into Inspect never reaches the address bar

Where this fits

  • Primary keys that do not scatter the index

    Generate v7 or ULID. Both put the timestamp first, so consecutive inserts land next to each other in a B-tree instead of all over it, and both stay ordered when several are made in the same millisecond.

  • A stable identifier derived from a name

    v5 in the DNS or URL namespace turns a name into a UUID deterministically, so the same input always maps to the same identifier and nothing has to be stored to look it up again.

  • Working out where an identifier came from

    Paste it into Inspect. The version and variant come off the octets, and a v1, v6, v7, ULID or Snowflake tells you when it was made.

  • Deciding whether something is unique enough

    Each format states how many bits are free and, from the birthday bound, roughly how many identifiers it takes before a collision becomes an even chance.

Frequently asked questions

Which version should I use?

v4 when nothing has to be ordered. v7 when the identifiers are database keys, because they sort by time and keep index inserts local. v5 when the identifier has to be derivable from a name. v1 is worth avoiding for anything new: it does not sort as a string, and it was designed to embed a MAC address.

Why does the tool say a batch does not sort in the order it was made?

Because for that format it does not. A v4 is random, so consecutive values land in an arbitrary order. The line above the list is measured on the batch on screen, not assumed from the format.

Will I ever get a duplicate?

For v4, the birthday bound puts an even chance of one collision at roughly 2.3 billion billion identifiers, so no. The formats that carry a timestamp are also protected by a counter, so several made in the same millisecond cannot repeat.

What does the chi-square test prove?

That every character occurs about as often as every other, which rules out a broken alphabet or a modulo bias. It does not prove the values are unguessable: Math.random passes the same test and its state can be recovered from a few outputs. The bits here come from crypto.getRandomValues, and that is the claim worth making.

Why is the timestamp in my Discord ID wrong?

Snowflake IDs are read against an epoch, and this tool uses Twitter’s, 4 November 2010. Discord and others chose their own, so the instant shown is off by the difference between the two. The panel says which epoch it used.

What is the format of a UUID?

Sixteen octets, written as 32 hexadecimal digits in five groups of 8-4-4-4-12. The high nibble of octet 6 is the version and the high bits of octet 8 are the variant; the Inspect panel marks both.

Further reading

  • How Computers Generate Random Numbers (and When It Matters)10 min read
  • UUIDs Explained: Universally Unique Identifiers and When to Use Them10 min read

Private by design

Conversions run on your device in JavaScript. The values you enter are never sent over the network.