Free Uuid Generator Online

Free UUID generator: random v4, time-ordered v7 and name-based v5 UUIDs, up to 1,000 at once, in any format, plus a UUID checker. Runs in your browser.

No login. Files processed for your request and discarded. Free to use. Files processed & discarded →

Compress PDF — it's free or choose from 130+ tools

130+ Free Tools
— Files Processed
— Happy Visitors
— Pages Explored
0 Files Stored

UUID Generator: Random v4, Time-Ordered v7 and Name-Based v5

Part of Text tools: See all Text tools.

What is Uuid Generator?

A UUID (GUID) generator for random version 4, time-ordered version 7 and name-based version 5 UUIDs, plus the Nil and Max UUIDs. Make up to 1,000 per click in lowercase or UPPERCASE, with or without hyphens, wrapped in braces, a urn:uuid: prefix or quotes. A checker shows the version, variant, repeats and any embedded time of UUIDs you paste. It runs in your browser.

How to use Uuid Generator

  1. Choose the UUID type: version 4 (random), version 7 (time-ordered), version 5 (from a name), Nil or Max.
  2. Set how many you need, up to 1,000, or for version 5 pick a namespace and type one name per line.
  3. Choose UPPERCASE, hyphens and wrapping (braces, urn:uuid:, or quotes with commas for JSON or SQL).
  4. Press Generate, then Copy all or Download .txt.
  5. To check existing UUIDs, paste them one per line into the checker and press Check.

Why use this tool?

Many UUID sites only make version 4. This one also makes version 7, which sorts by creation time and suits database primary keys, and version 5 for repeatable IDs from a name. Formats match what your code expects, and the checker decodes the version, variant and timestamp of any UUID. Everything uses the Web Crypto API in your browser and Files are processed for your request and discarded.

FAQ

Which UUID version should I use?
Use version 4 for most IDs. Use version 7 for database primary keys when you want new rows to sort by creation time and keep indexes compact, as long as revealing the creation time is acceptable. Use version 5 when the same name must always give the same UUID.
Are the UUIDs really unique?
Version 4 has 122 random bits from the browser's secure random generator. You would need about 2.7 x 10^18 of them for an even chance of one duplicate, so in practice duplicates come from bugs, not chance.
Are version 7 UUIDs in order?
Yes, within a batch. Each starts with the Unix time in milliseconds and a counter that rises inside the same millisecond, so a list of 1,000 is already sorted. IDs from different devices are only as ordered as their clocks.
Why does version 5 give the same UUID every time?
Version 5 is a SHA-1 hash of the namespace and the name. The same pair always gives the same UUID, which is the point. For example, DNS plus python.org gives 886313e1-3b8a-5372-9b90-0c9aee199e5d.
Can I get UUIDs without hyphens or in uppercase?
Yes. Untick Hyphens for the 32-digit form and tick UPPERCASE for capitals. You can also wrap each one in braces, add urn:uuid:, or quote them with commas for JSON or SQL.
What does the checker show?
Whether each line is valid, its version and variant, whether any line repeats, and for versions 1, 6 and 7 the creation time stored inside it in UTC. It accepts braces, urn:uuid:, uppercase and no hyphens.
Are my UUIDs sent anywhere?
No. Generating and checking happen in your browser. Nothing is sent to our server or stored.

What this UUID generator does

This page creates UUIDs (universally unique identifiers, also called GUIDs on Windows and in .NET) in the three versions developers actually use today. Version 4 is fully random and is the default. Version 7 starts with the current time in milliseconds, so new IDs sort in the order they were made, which keeps database indexes tidy. Version 5 is calculated from a namespace and a name, so the same input always gives the same UUID. You can also produce the special Nil UUID (all zeros) and Max UUID (all f), which some systems use as placeholders.

You can make up to 1,000 UUIDs per click, choose lowercase or UPPERCASE, keep or drop the hyphens, and wrap each one in braces, a urn:uuid: prefix, or quotes with commas ready to paste into a JSON array or an SQL IN (...) list. A second box checks UUIDs you already have: it tells you whether each line is valid, which version and variant it is, whether any line repeats, and for time-based versions the date and time stored inside it.

How to use it

Pick a UUID type, set how many you need and press Generate. If you only need one, set the number to 1 or simply copy the first line. Changing the type, case, hyphens or wrapping regenerates the list straight away. Copy all puts the whole list on your clipboard, and Download .txt saves it as a plain text file with one UUID per line (or comma-separated when you choose a quoted format).

For version 5, choose a namespace and type one name per line. The standard namespaces are DNS for domain names such as example.com, URL for full addresses, OID for ISO object identifiers and X.500 for directory names. If your project defines its own namespace, choose Custom and paste that namespace UUID. Names are encoded as UTF-8 exactly as typed, so Example.com and example.com give different results, and a trailing space changes the UUID too.

To check existing values, paste them into Check or decode a UUID, one per line, and press Check. Braces, the urn:uuid: prefix, uppercase letters, a missing set of hyphens, quotes and trailing commas are all accepted, so you can paste straight from logs, code or a spreadsheet. Check these copies the list you just generated into the checker.

Which version should you use?

  • Version 4 (random) is the safe general choice: request IDs, file names, idempotency keys, test data and most primary keys. It reveals nothing about when or where it was made. Browsers expose the same thing as crypto.randomUUID(), and most languages have a built-in v4 function.
  • Version 7 (time-ordered) suits database primary keys, especially in B-tree indexes such as PostgreSQL, MySQL InnoDB and SQL Server. Because each new value is larger than the last, inserts go to the end of the index instead of random pages, which usually means less page splitting and better cache use. The trade-off is that anyone who sees the ID can read the creation time to the millisecond.
  • Version 5 (name-based) is for when you need the same ID every time for the same thing: an ID derived from an email address, a URL or a product code, so separate systems agree without talking to each other. It is not secret. Anyone who knows the namespace and guesses the name can reproduce it, so never use it to hide data.
  • Nil and Max are fixed values, not identifiers. Use them only where a format requires a placeholder for "no value" or "greater than any real UUID".

Versions 1 and 6 (time plus a node field that may be a network card address) and version 3 (name-based with MD5) are not generated here. They are older or narrower in use, and RFC 9562 itself recommends version 7 over 1 and 6 and version 5 over 3 for new systems. The checker still recognises and decodes all of them.

How the UUIDs are made

Every version 4 UUID uses 16 bytes from the browser's cryptographically secure random number generator (crypto.getRandomValues). Six bits are then fixed: four mark the version and two mark the standard variant, leaving 122 random bits. Version 7 follows RFC 9562: the first 48 bits are the Unix time in milliseconds, then the version, then 12 bits that act as a counter, then the variant and 62 random bits. When you generate many in the same millisecond, the counter goes up by one each time, so a batch of 1,000 comes out already in sorted order, and if the counter runs out the timestamp moves forward by one millisecond rather than breaking the order. Version 5 hashes the 16-byte namespace followed by your name with SHA-1 through the Web Crypto API and keeps the first 128 bits with the version and variant set.

You can verify the version 5 code against a published value: the DNS namespace with the name python.org gives 886313e1-3b8a-5372-9b90-0c9aee199e5d, the same result Python's uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org') returns. The checker was tested with the example UUIDs printed in RFC 9562; the version 1, 6 and 7 examples all decode to 22 February 2022, 19:22:22 UTC, as the standard says they should.

Are random UUIDs really unique?

Not guaranteed, but close enough that you can treat them as unique. With 122 random bits there are about 5.3 x 10^36 possible version 4 values. By the birthday rule, you would need roughly 2.7 x 10^18 of them before there is an even chance that any two match. If you create a billion, the chance of a single duplicate among them is about 1 in 10^19. In practice, duplicates come from bugs, not chance: a badly seeded random generator, copying test data into production, or code that reuses a variable. That is why the checker flags repeated lines.

Version 7 trades some randomness for the timestamp but still has 74 bits that are random or counter, and collisions would need two IDs created in the same millisecond with the same random bits. Version 5 is deliberately not unique across inputs: the same namespace and name always give the same value, and two different names collide only if SHA-1 collides on them.

Formats: hyphens, case, braces and URN

The standard text form is 32 lowercase hexadecimal digits in groups of 8-4-4-4-12, for example 550e8400-e29b-41d4-a716-446655440000. RFC 9562 says software should output lowercase and accept either case on input. Microsoft tools usually show GUIDs in uppercase inside braces, such as {550E8400-E29B-41D4-A716-446655440000}, which is why the braces option exists. The 32-digit form without hyphens is common in URLs and some databases; it carries the same value. The URN form urn:uuid:... is used in XML and some metadata standards; it always keeps the hyphens because that is how the URN is defined.

For storage, prefer a native UUID column (PostgreSQL uuid, SQL Server uniqueidentifier) or 16 raw bytes (MySQL BINARY(16)) over a 36-character text column. Text works, but it takes more than twice the space and is slower to index. Be aware that SQL Server sorts uniqueidentifier values by a different byte order, so version 7 IDs are not in time order there unless you store them as binary.

What the checker tells you

For each line it reports whether it is a valid UUID, the normalised lowercase form, the version (the first digit of the third group) and the variant (set by the first digit of the fourth group: 8, 9, a or b means the standard variant). For version 7 it reads the millisecond timestamp. For versions 1 and 6 it rebuilds the 60-bit count of 100-nanosecond intervals since 15 October 1582, shows it as UTC, and shows the node field, noting when the multicast bit says it is probably random rather than a hardware address. Times are shown in UTC to the millisecond; convert them to your zone with the timestamp converter linked below.

What this tool does not do

It does not create version 1, 3, 6 or 8 UUIDs, ULIDs, Snowflake IDs or short IDs such as NanoID. It does not keep a history or check your UUIDs against any database, so "no repeats" only covers the lines you pasted. It cannot prove that a UUID was generated randomly: a hand-typed value with the right digits passes as version 4. Version 7 order is guaranteed within one batch on one page; IDs made on different devices are ordered only as well as their clocks agree. Finally, a UUID is an identifier, not a password or access token. Unguessable is not the same as secret, and anything that grants access should be checked on your server.

Privacy

Generation and checking run entirely in your browser. The UUIDs, names and pasted values are not sent to our server or saved, and closing the tab discards them. The download file is created on your device too.

Related tools

Turn a version 7 or Unix timestamp into a readable date in any time zone with the timestamp converter, make a strong random password with the password generator, create SHA-256 or MD5 checksums with the hash generator, and tidy the JSON you paste your IDs into with the JSON formatter.

Also try

Related tools that work well with this one: