Fast and Developer ready GUID Generator & Validator
Use our offline GUID Generator & Validator to create cryptographically secure Version 4 UUIDs. Validate up to 10,000 identifiers locally with zero server uploads.
Table of Contents
Seeding a database or wiring up test records that each need their own unique ID? Generate version 1 or version 4 UUIDs one at a time or in bulk, and paste an existing identifier to confirm it is correctly formed and see which version it is. UUIDs matter because they let separate systems create IDs that will not collide without asking a central server, and getting the format or version wrong causes subtle bugs later. The tool creates them locally using the browser crypto API, so you can spin up as many as a test run needs without a network round trip, and the validator explains why a malformed one is rejected rather than just failing. It suits developers seeding databases, testers building fixtures, and anyone integrating a system that expects a specific UUID version. Nothing is uploaded, and it works offline once loaded.
🆔 ID Studio Pro
Generate, inspect and validate UUIDs, ULIDs, NanoIDs and other unique identifiers — entirely in your browser.
| Field | Value |
|---|
Versions 1, 6 and 7 carry a creation time inside them, so the timestamp row shows a real date. Version 4 does not — it is random from end to end.
Which version should you pick?
v4 is 122 random bits and the safe default when you just need something unique and unguessable.
v7 starts with a millisecond timestamp, so generated values sort in creation order. That single property makes a large difference as a database primary key: v4 keys scatter across a B-tree index and cause page splits on every insert, while v7 keys append in order.
v1 and v6 also embed a timestamp. v1 places the time fields in an order that does not sort correctly as text; v6 rearranges the same data so it does.
Related tools
- Strong Password Generator — for human secrets, not machine IDs
- Secure Hash Generator — SHA-256 and MD5 checksums
- JWT Decoder & Inspector — for tokens carrying an ID
- Dummy Data Generator — full fake records, not just IDs
- CSV to SQL Converter — turn an ID list into INSERT statements
Calculates mathematically secure random numbers to generate Version 4 identifiers with practically zero collision probability.
Executes complex regex parsing to instantly authenticate strings containing hyphens, braces, and standard hexadecimal formatting.
Capable of calculating and formatting up to 10,000 unique 128-bit strings locally within a single execution cycle.
Choose between calculating new 128-bit identifiers or authenticating an existing list of hexadecimal strings.
Determine the exact output formatting by toggling hyphens, uppercase lettering, or surrounding braces.
Specify your desired array length up to 10,000 items and trigger the local cryptographic number generator.
Download the generated array as a raw text file, or review the parsed results table to identify invalid strings.
Last Updated: August 2026
🔴 What Changed and Why
This page used to be a version 4 uuid generator with a validator attached. That covers the common case, but it left out the question people actually arrive with: which kind of identifier should I be using here? So the page now generates seven UUID variants plus five other identifier schemes, and it can pull a UUID apart to show you what is inside it.
Generate — pick the version that fits the job
Version 4 stays the default because it is the right answer most of the time: 122 random bits, no structure, nothing leaked. Version 7 is the one worth knowing about if you are choosing a database primary key, and the reason is worth spelling out.
A v4 UUID is random from the first character. Insert a million of them into an indexed column and each row lands at an unpredictable point in the B-tree, so the database keeps splitting pages and the index grows far larger than the data warrants. A v7 UUID starts with a 48-bit millisecond timestamp, so newly created rows sort to the end and append cleanly. Same uniqueness guarantee, very different write behaviour.
Generate ten of each and the difference is visible immediately. Ten v4 values look like noise. Ten v7 values share a common prefix that ticks upward:
019f75da-1b74-7000-a186-9d6b5d28ef0c019f75da-1b74-7001-b2c4-3f8a1e5d7b90019f75da-1b74-7002-8e13-6a2f9c4d1e58
Note the fourth group climbing 7000, 7001, 7002. That is a monotonic counter, not an accident. When several identifiers are created inside the same millisecond the timestamp alone cannot separate them, so the counter keeps the sort order intact. Generate all ten thousand at once and they still come out in order.
Inspector — read what is inside an identifier
Paste any UUID and the panel reports its version, its variant, the raw hex, the full 128-bit integer, and a base58 short form. For versions 1, 6 and 7 it also decodes the embedded timestamp into a readable date.
That last row answers a question that comes up more often than you would expect: when was this record actually created? If the ID is a v7 and the created_at column is missing or untrustworthy, the answer is sitting inside the key itself, accurate to the millisecond.
Other Formats — five schemes that are not UUIDs
🔵 ULID — 26 characters, timestamp first, sorts as plain text. Its alphabet drops I, L, O and U, so a generated value cannot accidentally spell something unfortunate and cannot be misread over the phone.
🟠 NanoID — 21 URL-safe characters by default, adjustable from 6 to 64. Shorter than a UUID with a similar collision profile, which is why it turns up in URLs and share links.
🟣 MongoDB ObjectID — 24 hex characters: four bytes of Unix seconds, five random bytes, then a three-byte counter.
🔵 Snowflake — a 64-bit number that fits a bigint column, which a 128-bit UUID does not.
🟠 Short UUID — an ordinary v4 encoded in base58, trimming 36 characters to roughly 22 without discarding a single bit.
Validate & Convert — bulk work
Paste a list and it counts valid against invalid, accepting hyphenated, bare hex, braced and quoted forms. Then convert the valid ones to canonical form, raw hex, a 128-bit decimal integer, base58, CSV rows or a JSON array.
🟡 Where People Get This Wrong
A UUID is not a secret
This is the mistake with real consequences. A v4 UUID is unguessable, which tempts people into using one as a password reset token or an API key. It is the wrong tool. It has no expiry, no revocation, no rate limiting, and it frequently ends up in server logs, browser history and referrer headers. For anything that grants access, use the Strong Password Generator or a purpose-built token scheme.
Time-based versions reveal their creation time
v1, v6 and v7 all carry a timestamp that anyone can read — the Inspector tab proves it in one paste. Usually harmless. Occasionally not: a public v7 identifier tells the world exactly when the account, order or document behind it was created, and sequential v7 keys in a URL make it trivial to estimate how many records exist. If either matters, v4 is the version to pick.
Storing UUIDs as text
A UUID stored as a 36-character string takes 36 bytes. The same value as binary takes 16. Across millions of rows that difference lands squarely on index size and query speed. Most databases have a native type for this — use it rather than a VARCHAR.
What this page does not do
🔵 Versions 3 and 5 are absent on purpose. They derive a UUID by hashing a name inside a namespace, which needs MD5 or SHA-1, and hashing has its own page here rather than being duplicated inside this one. See the Secure Hash Generator.
🟠 Real MAC addresses in v1 and v6 are impossible from a browser, which cannot read network hardware. The node field is filled with random bits and the multicast flag is set — exactly what the specification instructs implementations to do when no hardware address is available. The Inspector labels which of the two it found.
🟣 The CUID2 option produces a correctly shaped identifier from browser randomness, not the reference algorithm. It is good for seeding test data; for production, install the official library.
Honest limits
Generation is capped at 10,000 per run. It is a soft ceiling — the browser copes, but a textarea holding a hundred thousand lines becomes unpleasant to scroll on any device. For a larger batch, run it a few times and save each file. The v7 monotonic counter allows 4,096 values per millisecond; beyond that the timestamp rolls forward by one millisecond, so ordering holds either way.
🟢 The Reasoning Behind It
For the deeper background — how 128 bits produces a practical collision probability of zero, what the birthday problem actually says about it, and why the original MAC-address design became a privacy problem — there is a companion article: UUID and GUID explained: versions, collisions and safe use.
The current specification is IETF RFC 9562, published in 2024, which replaced RFC 4122 and introduced versions 6, 7 and 8. Browsers also ship a built-in v4 generator documented at MDN’s crypto.randomUUID reference.
❓ Frequently Asked Questions
Are these UUIDs generated on your server?
No. Every value comes from your browser’s own cryptographic random source. Nothing is sent anywhere, and no record of what you generated exists outside your tab.
Should I use v4 or v7?
v7 for database primary keys, because it sorts by creation time and keeps the index tidy. v4 anywhere the identifier is public and you would rather not reveal when it was made.
Can two UUIDs ever be the same?
In principle yes, in practice no. You would need to generate around 2.7 quintillion v4 values before a collision reached a one-in-a-billion chance.
Is a UUID safe to use as an API key?
No. It is unguessable but it never expires, cannot be revoked cleanly and leaks into logs and referrer headers. Use a token scheme designed for authentication.
Why does the tool not offer v3 or v5?
Both are name-based and require MD5 or SHA-1. Hashing lives in its own tool on this site rather than being repeated here.
What is the difference between a UUID and a GUID?
Nothing structural. GUID is Microsoft’s name for the same 128-bit value, which is why you often see it wrapped in braces in Windows tooling.
Why do my v1 UUIDs not contain my MAC address?
Browsers cannot read network hardware. The node field uses random bits with the multicast flag set, which is what the specification requires when no hardware address is available.
What is ULID good for?
Cases where you want v7’s time ordering but shorter, case-insensitive text. Its 26-character base32 form is easier to read aloud and to type by hand.
Does the 10,000 limit mean bigger batches are unsafe?
Not at all — it is a usability cap. Uniqueness and ordering hold at any size; a textarea with a hundred thousand lines simply becomes awkward to use.
