UUID Generator

A fresh version 4 UUID is already waiting in the box above. Press Copy to put it on your clipboard, or the round arrow for a new one. Change any setting and a new result appears at once, so there is no Generate button to look for and nothing to sign up for.

This UUID generator makes every common kind of identifier: v4 (random), v7 (time-ordered), v1 (time plus a random node), v5 and v3 (made from a name), and the two special values NIL and MAX. You can make 1 to 10,000 at a time, change the format, copy them all, or download them as a TXT, CSV, JSON or SQL file.

Below the settings there is a decoder. Paste any UUID or GUID and it tells you whether it is valid, which version and variant it is, and, for v1, v6 and v7, the exact time it was made. Everything happens in your own browser, using crypto.getRandomValues, and nothing is sent to a server.

A UUID (universally unique identifier) is a 128-bit number used as an ID. It is normally written as 32 hexadecimal digits in five groups of 8, 4, 4, 4 and 12, joined by dashes, for example 0f8fad5b-d9cb-469f-a165-70867728950e.

The point of a UUID is that anyone can make one, on any computer, at any time, without asking a central server for the next number, and still be confident it will not clash with anyone else's. That is why they are used for database rows, files, API requests, messages, devices and test data.

Two digits inside every UUID carry meaning. The first digit of the third group is the version, such as 4 or 7. The first digit of the fourth group shows the variant; for standard UUIDs it is 8, 9, a or b. Everything else is time, random bits or a hash, depending on the version. The current standard is RFC 9562, published in 2024, which replaced RFC 4122 and added versions 6, 7 and 8.

GUID stands for globally unique identifier. It is Microsoft's name for exactly the same thing: a 128-bit ID in the same 8-4-4-4-12 layout. A GUID made by Windows, .NET or SQL Server is a UUID, and a UUID made here can be used anywhere a GUID is expected.

The only differences are habits of writing. Microsoft tools often show GUIDs in UPPER CASE and wrapped in curly braces, like {0F8FAD5B-D9CB-469F-A165-70867728950E}. Tick UPPER CASE and {Braces} (Microsoft GUID) under Format and every result is written that way. If you were looking for a guid generator online, this page is one: the same values, just a different label.

One technical detail: Windows stores the first three groups of a GUID in little-endian byte order in memory. That changes how the raw 16 bytes look, not how the text looks, so it only matters if you copy bytes between systems by hand.

This is a UUID generator free for everyone, with no account, no daily limit and no adverts inside the tool. Every version, every format and every download type is available to all, and 10,000 UUIDs take about the same effort as one.

Because the work happens on your device, there is no server to queue behind and no upload of any kind. Once the page has loaded it keeps working even if your connection drops.

A random UUID generator online is only as good as its random numbers. This one takes every random bit from crypto.getRandomValues, the cryptographically secure random source built into every modern browser. It is the same kind of randomness used for encryption keys, not the predictable Math.random that some quick scripts use.

For a version 4 UUID the tool asks for 16 random bytes, then sets 4 bits to mark version 4 and 2 bits to mark the standard variant. That leaves 122 truly random bits. For v7 and v1, the random part fills everything that is not time, version or variant.

Using a uuid generator online that runs in the browser also means the values exist only on your screen and your clipboard. No copy is kept on any server, which matters if you use them as secret-looking links or invitation codes.

A uuid generator v4 result is the default here because it is the safest general choice. It contains no time, no device information and no pattern, so you can show it publicly without leaking anything.

Are duplicates possible? In theory, yes. In practice, the odds are so small that they are not worth planning for, as long as the random source is good. With 122 random bits there are about 5.3 × 10³⁶ possible values. The chance of any duplicate grows with the square of how many you make (the birthday problem), and the table below shows real numbers.

The honest caveat is that real-world duplicates almost always come from bugs, not maths: a weak random generator, a virtual machine image that copies its random state, code that caches one value and reuses it, or the same list pasted twice. A UNIQUE constraint on the database column is still a good idea as a safety net.

A uuid generator v7 result starts with a 48-bit Unix timestamp in milliseconds. Then come the version digit 7, 12 more bits, the variant, and 62 random bits. Because the time is at the front, UUIDs made later always sort after UUIDs made earlier, both as text and as bytes.

This tool uses the 12 bits after the version as a counter. If you make many v7 UUIDs within the same millisecond, the counter goes up by one each time, so the list stays in strict order instead of being shuffled by the random part.

Why is v7 better for database primary keys? Most databases store a primary key in a B-tree index. Random v4 keys land in random places in that tree, so every insert touches a different page, pages split often and the cache works hard. Time-ordered v7 keys are always added near the end, much like an auto-increment number, so inserts are faster, indexes stay smaller and recent rows sit close together. You also get a rough creation time for free and can sort by ID.

The trade-off is that a v7 UUID reveals when it was made. If that time is private, for example the moment a user signed up, and the ID is shown publicly, use v4 instead. v7 also has fewer random bits than v4, but 62 random bits per millisecond is still far more than enough to avoid clashes.

Version 1 is the original time-based UUID. It holds a 60-bit count of 100-nanosecond steps since 15 October 1582 (the start of the Gregorian calendar), a 14-bit clock sequence and a 48-bit node.

Traditionally the node was the computer's network card MAC address, which leaked hardware details. This tool never uses a MAC address: the node is 6 random bytes with the multicast bit set, as the standard allows, and the clock sequence is picked at random once per page load. If you make several v1 UUIDs for the current time, each one gets a time at least one step after the last, so none repeat.

The time in v1 is split and stored in a scrambled order (low bits first), so v1 UUIDs do not sort by time as text. That is why version 6 and version 7 were added. Use v1 only when an older system asks for it; MySQL's UUID() function and some Cassandra setups still use it.

Versions 5 and 3 are not random at all. They hash a namespace UUID together with a name, so the same namespace and name always give the same UUID, on any computer, in any language. Version 5 uses SHA-1 and version 3 uses MD5; choose v5 unless you must match a system that already uses v3.

Pick a namespace from the list (DNS, URL, OID or X500) or choose Custom UUID and paste your own. Then type the names, one per line. Each line becomes one UUID, in the same order, so a list of 500 email addresses gives 500 matching IDs. The How many box is hidden for these versions because the number of lines decides the count.

You can check the tool against published examples. With the DNS namespace, the name python.org gives 886313e1-3b8a-5372-9b90-0c9aee199e5d as v5 and 6fa459ea-ee8a-3ca4-894e-db77e160355e as v3. The default name flipmyformat.com gives 71a06736-0d00-5bbe-aad5-e513b7bb29d9 as v5. Name-based UUIDs are handy for stable IDs from URLs, product codes or file paths, but they are not secret: anyone who knows the name can make the same UUID.

The NIL UUID is 00000000-0000-0000-0000-000000000000. Use it as a placeholder for empty or unknown, for example as a default value in a form or a test.

The MAX UUID is ffffffff-ffff-ffff-ffff-ffffffffffff. RFC 9562 defines it as a sentinel, useful as the upper end of a range or a marker for no limit. Both are fixed, so How many simply repeats the same value.

A uuid generator with timestamp support is useful when you need IDs that match a real moment, such as backfilling old records or writing tests. Choose v7 or v1 and a field appears: Use this time instead of now. Pick a date and time, and the UUIDs are built from that moment instead of the current clock.

When you make a list with a custom time, each UUID is one millisecond later than the one before, so a list of 1,000 covers exactly one second and stays in order. Press now next to the field to go back to the live clock.

To read the time back, paste a UUID into Check or decode a UUID. For v7 it shows the millisecond the UUID was made; for v1 and v6 it converts the 100-nanosecond count back into a normal date. The time is shown in UTC and in your local time zone.

The Format options change how every result is written. They do not change the value, so you can switch them back and forth freely; copy and download always use the format you see.

UPPER CASE uses capital letters A to F. With dashes keeps the standard 8-4-4-4-12 layout; untick it for 32 digits in a row. {Braces} (Microsoft GUID) wraps each value in curly braces. urn:uuid: prefix adds the official URN form used in XML and some standards. You can combine them.

Untick With dashes and this works as a uuid generator without dashes: each result becomes 32 hexadecimal characters, such as 0f8fad5bd9cb469fa16570867728950e. Nothing is lost; the dashes are only there to make the value easier to read.

The compact form is common in file names, URL paths, cache keys, Redis keys and databases that store UUIDs in a CHAR(32) column. Hex digits are safe in every URL and file system. If a system later needs dashes again, they go after characters 8, 12, 16 and 20, and the decoder here reads either form.

Set How many to any number from 1 to 10,000. As soon as there is more than one, the result box becomes a numbered list with New list, Copy all and four download buttons. The list shows the first 2,000 on screen to keep the page fast, but Copy all and every download include all of them.

Copy all puts one UUID per line on the clipboard. The downloads are named uuids.txt, uuids.csv, uuids.json and uuids.sql, and they use the format options you have ticked.

Paste anything that looks like a UUID into Check or decode a UUID. It accepts upper or lower case, with or without dashes, with curly braces and with the urn:uuid: prefix.

If the text is not 32 hex digits it says so. If it is valid, it shows the version (1 to 8), the variant (RFC 9562 for modern UUIDs, or the old NCS and Microsoft variants), and a note for NIL and MAX. For v1, v6 and v7 it also shows the time the UUID was made. This is handy for checking which version a library really produces, or for finding when a v7 record was created from its ID alone.

Excel has no built-in UUID function, so the easiest way to use a uuid generator for Excel work is to make the list here. Set How many to the number of rows you need, press Copy all, click the first cell of your column and paste: each UUID lands in its own row. Or download the CSV and open it directly; the column is headed uuid.

Pasted values are fixed, which is usually what you want for IDs. A formula is the other route. This one builds a version 4 shaped value in a single cell:

Copy it down as far as you need. Be aware of two limits. RANDBETWEEN is not a cryptographic random source, so treat the result as fine for spreadsheets and test data, not for security. It is also volatile: every edit recalculates the sheet and changes every value, so copy the column and use Paste Special, Values to freeze them.

In Power Query you can add a custom column with Text.NewGuid(), which also gives random v4 values. Google Sheets has no UUID function either, and pasting a list from here works there in the same way.

Postman has its own dynamic variables, so you may not need a uuid generator for Postman requests at all. Type {{$guid}} or {{$randomUUID}} in a URL, header or body, and Postman puts a new random version 4 value there every time the request is sent. In a pre-request script, pm.variables.replaceIn("{{$guid}}") returns one you can store.

Generate the values here when you need something Postman does not offer: the same ID across several requests, a v7 or v5 value, a specific format such as no dashes, or a fixed list for a data-driven run. For a fixed ID, copy one and save it as an environment or collection variable. For many runs, download the CSV and choose it as the data file in the Collection Runner; the header uuid becomes the variable {{uuid}}, with one row per iteration.

Most languages and databases can make UUIDs too, which is the right choice inside running software. This page is for the moments in between: test data, one-off IDs, seeding a table, checking what a value is, or making names into stable v5 IDs.

Every UUID is made by JavaScript running in this page. Nothing you generate, type or decode is sent to a server, logged or stored. Only your settings are remembered in this browser's local storage, and you can clear them with your browser's site data.

UUIDs are identifiers, not passwords. A v4 value is very hard to guess, but it was not designed as a secret and often ends up in logs and links. For passwords use the Password Generator, and for checksums or fingerprints of text and files use the Hash Generator.

Building test data? Format a JSON fixture with the JSON Formatter, turn a CSV of IDs into JSON with CSV to JSON, or go the other way with JSON to CSV.

Need other developer helpers? The Hash Generator makes MD5, SHA-1 and SHA-256 hashes, the Password Generator makes strong random passwords and passphrases, and the Diff Checker compares two lists to spot a missing ID.