UUID Generator

Generate one or many random UUID v4 identifiers.

This tool runs entirely in your browser. Your data is never uploaded, never stored, and never leaves your device.

Produces version 4 UUIDs — 128-bit random identifiers in the familiar 8-4-4-4-12 hexadecimal form — singly or in batches of up to a hundred.

How to use it

1Set how many you want in the count box, from 1 to 100.
2Press Generate; the identifiers are listed one per line.
3Use the copy button above the list to take the whole batch at once.

Example

Input: Count 500, then Generate
Output: 100 UUIDs, one per line, and the count box snaps back to 100

Out-of-range counts are clamped rather than refused — 500 becomes 100 and 0 becomes 1. Every value comes from the browser's crypto.randomUUID(), so it is cryptographically random with no timestamp inside, which means v4 UUIDs cannot be sorted into creation order.

What happens to your data

Randomness comes from your own device via the Web Crypto API, and the generated values stay in the page. Nothing is transmitted, so an identifier made here exists nowhere but your clipboard until you use it.

Last updated August 2026

Generate universally unique identifiers (UUIDs / GUIDs) for database keys, request IDs, idempotency keys, and distributed systems — one at a time or in bulk. UUIDs let independent systems create identifiers that won't collide, without a central coordinator.

This produces standard version-4 (random) UUIDs instantly, ready to copy into code, migrations, or test data.

Before you generate anything, decide whether you want an identifier that is purely random or one that sorts. Version 4 is random the whole way through, which is what you want wherever the identifier will be visible outside your own system: two of them reveal nothing about each other, and nothing about the machine or the moment that made them. That indifference is also the cost. A random key arrives at a B-tree index in no order at all, so a busy table keyed on one writes across the whole index rather than appending to the end of it. Where you want keys that land roughly in the order they were created, the version to reach for is 7 — a millisecond timestamp in the leading bits, random after that.

The format itself carries no meaning. It is not a checksum, it does not record who issued it, and nothing in a UUID tells you whether it came from a cryptographic source or from a Math.random loop someone wrote in a hurry. Treat any one you did not generate yourself as an opaque string.

How it works

Toolvore generates UUIDs in your browser using the secure random generator. Nothing is requested from a server, so bulk generation is instant and private. Version 4 is the only version on offer, because crypto.randomUUID is the browser's own generator and that is the one thing it makes: 36 lowercase characters with the hyphens in, and no switch for uppercase, braces or a stripped form. The count is corrected rather than refused — ask for 500 and the field rewrites itself to 100, ask for 0 or leave it blank and it becomes 1, ask for 7.9 and you get 7 — so check the box after you press Generate. Each press replaces the previous list rather than adding to it, which catches anyone working in batches: copy what you have before you go again. The single Copy button takes every line at once, joined by newlines, and stays disabled while the box is empty; there is no per-row copy and no file to download.

Common use cases

Primary keys and foreign keys in databases
Correlation and request IDs for tracing and logging
Idempotency keys for safely retrying API calls
Unique identifiers in test fixtures and seed data
Naming uploaded files so two uploads cannot overwrite one another
Device or installation IDs generated on first run, with no server round trip

Frequently asked questions

What UUID version does this generate?＋

Version 4 — randomly generated UUIDs, the most common choice for general-purpose unique IDs.

Can UUIDs collide?＋

The probability is negligibly small for practical purposes — v4 UUIDs draw from 122 random bits.

Are they generated privately?＋

Yes — locally in your browser, never on a server.

Should I use a UUID as a primary key in Postgres or MySQL?＋

It works, and the cost sits in the index rather than the column. Random keys arrive at a B-tree in no order, so each insert lands on a different page and the part of the index held in memory stops being the part you need. InnoDB stores the table itself in primary key order and copies that key into every secondary index, which makes the choice more expensive there than in Postgres. Store it as a native type either way — Postgres has a uuid type holding the 16 bytes, MySQL wants BINARY(16) with UUID_TO_BIN — because CHAR(36) is more than twice the width in every index that mentions it.

What is the difference between UUID v1, v4 and v7?＋

Version 1 is a timestamp plus a clock sequence plus a node identifier that was historically the machine's MAC address, so it leaks where and when it was made, and its time field is stored low-order first, so a lexicographic sort does not match a chronological one. Version 4 is random apart from the six bits recording the version and variant. Version 7 puts a Unix millisecond timestamp in the leading 48 bits and fills the rest randomly, so sorting the strings sorts by creation time — the reason it is now the usual advice for keys. RFC 9562, published in 2024, added versions 6, 7 and 8 and replaced RFC 4122.

What is the difference between a UUID and a GUID?＋

The same 128 bits under two names, GUID being the Microsoft one. Most of the difference is cosmetic — registry and COM style prints uppercase inside braces — but one part is a real trap. The .NET Guid type holds its first three fields in the machine's native byte order, so ToByteArray does not return the bytes in the order the printed string suggests, while Java's UUID and most other implementations are big-endian throughout. Round-trip a GUID as raw bytes between a .NET service and anything else and the first three groups come back reversed, which looks like corruption and is not. Pass the canonical string across the boundary instead.

Are UUIDs case sensitive, and can I strip the hyphens?＋

The specification says emit lowercase and accept either case on input, so the uppercase and lowercase spellings are the same identifier. Your code does not know that. String comparison is case sensitive, map keys are case sensitive, and a text column with a unique index will hold both spellings as two separate rows — which is how a .NET service, where uppercase is the default rendering, ends up disagreeing with a Node one about whether a record already exists. Normalise at the edge, or use a real uuid column, which parses what you give it and re-emits the canonical form. The hyphens are equally optional and worth keeping: every log line is easier to scan with them.

Is a UUID safe to use as a password reset token?＋

The entropy is rarely the weak part — a version 4 from a cryptographic source has 122 unpredictable bits, which nobody is going to guess. The weak parts are around it. Other versions are not random at all: version 1 is a clock reading, versions 3 and 5 are a hash of a name someone can guess, and some older libraries fill a version 4 from a non-cryptographic generator whose state can be recovered from a handful of outputs. A token carried in a URL also escapes by other routes — browser history, the Referer header sent by any third-party asset on the page, server logs, link previews in chat apps. Give it a short expiry and a single use rather than leaning on the bits alone.

How do I get the same UUID every time from the same input?＋

Reach for a name-based version rather than a random one. Version 5 hashes a namespace UUID together with a name using SHA-1 and writes the version and variant bits into the digest; version 3 does the same with MD5. The same namespace and name produce the same identifier on any machine, at any time, with nothing coordinating them — which is how you assign a stable id to a URL, a file path, or a row imported from a system that has its own key and no UUID. There are predefined namespaces for DNS names, URLs and OIDs, and any UUID of your own works as one. The trade is that it is guessable by construction, so it is never a secret.