UUID Generator
Generate random UUID v4 identifiers in bulk, with or without dashes, in your browser.
A UUID - universally unique identifier - is a 128-bit value formatted as a string of 32 hex characters split by dashes into five groups. Version 4, the variant this generator produces, fills most of those bits from a cryptographic random source, which means every value is effectively unique without needing a central coordinator or a counter.
Pick how many identifiers you need and the format, and press Generate. Values are produced with crypto.getRandomValues, the same secure random source browsers use for TLS keying - not Math.random, which is far weaker and must never back identifiers. Each result has its own Copy button so you can move them into code or a database one at a time.
UUIDs are the default choice for database primary keys, message correlation IDs, entity identifiers and anywhere you need a value that will not collide across systems. They are deliberately opaque and non-sequential, so unlike auto-incrementing numbers they reveal nothing about how many were created or in what order.
7e4ed5ad-d798-4571-bdf6-32e1e3980f30bdfd365e-70a3-4b8f-a360-72dc786d92a7d7bcf102-4111-4744-aca1-74a6f8de69a7db83ffa9-1ad0-41fc-ad07-f87b6c7bbe92f36461d5-82f3-4b3c-87cb-d35c58a2c2e9
Features
- Generate 1 to 100 UUID v4 values in one click.
- Cryptographic randomness from crypto.getRandomValues - never Math.random.
- Formats: standard with dashes, no dashes, or uppercase.
- Per-line copy buttons for moving values into code or a database.
- Version and variant bits set correctly per RFC 4122.
- Runs entirely in your browser - nothing is uploaded or stored.
How to Use
- 1
Choose a count
Enter how many identifiers you need - typically one for a primary key or a handful for a batch insert. The maximum is 100 per run.
- 2
Pick a format
Standard keeps the familiar xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx shape. No dashes produces the compact 32-hex form some databases store. Uppercase matches the style some teams and tools expect.
- 3
Generate
Press Generate for a fresh set. Every value is computed on the spot from the secure random source, so each run is different.
- 4
Copy what you need
Each value has a Copy button. Paste identifiers straight into a schema, an INSERT statement or a correlation header.
Example
Standard format
Count: 1 · Format: With dashes↓
4f3a5c9e-1b7d-4e8a-9c2f-0d6b5a4e3f2aCompact, uppercase
Count: 1 · Format: No dashes · Uppercase↓
4F3A5C9E1B7D4E8A9C2F0D6B5A4E3F2ACommon Problems
Using Math.random to build IDs
Math.random is a fast but weak pseudo-random generator. Two machines initialised the same way can produce identical sequences, and its output is predictable enough that generated IDs become guessable. UUID v4 relies on a cryptographic source instead.
Expecting UUIDs to be sequential
Version 4 UUIDs are random, not ordered. A new row will not have a larger ID than the previous one. If you need sortable keys, add a separate timestamp or sequence column.
Assuming version 1 and version 4 are interchangeable
Version 1 embeds the MAC address and a timestamp; version 4 is random. Version 1 can reveal when a value was created and on which machine. For privacy, prefer version 4 - which is what this generator emits.
Treating UUIDs as guaranteed-unique
The probability of a collision is astronomically small but not zero. That is fine for essentially every practical system - the risk is comparable to a hardware failure losing the row anyway. Still, never assume uniqueness across every system in the universe; scope your assumptions to what is reasonable.
Formatting UUIDs inconsistently
The same identifier can be written with or without dashes and in upper or lower case. Mixing those forms across a codebase turns exact matches into "why is this not found?" bugs. Pick one canonical form - usually lowercase with dashes - and normalize before comparing.
Technical Details
Values are generated per RFC 4122 version 4: 122 of the 128 bits are filled from crypto.getRandomValues, with the version nibble set to 4 and the variant bits set to the RFC 4122 form.
The output is the canonical 36-character form, the 32-hex compact form, or the uppercase variant. All three represent the same 128-bit value.
Generation happens on demand in the browser using the platform's secure random source. No request is made to a server and no history of generated values is kept.
A standard v4 UUID has 122 random bits, giving roughly 5.3 × 10^36 possible values. Collisions require generating around 2.7 × 10^18 values for a 50% chance - far beyond any real system.
UUID generation requires no server and no coordinator, which is what makes it attractive in distributed systems, offline clients and event sourcing: any node can mint identifiers that will not clash with identifiers minted anywhere else.
Frequently Asked Questions
What does v4 mean in UUID v4?
The version number describes how the identifier is made. Version 4 fills the value from a random source, version 1 uses a timestamp plus the machine's MAC address, and version 7 uses a timestamp plus randomness. Version 4 is the most common because it is simple and leaks no machine information.
Are UUIDs safe to use as database primary keys?
Yes, with one caveat about storage. Random UUIDs break sequential index locality, which can slow down insert-heavy workloads on large tables. Using the compact binary form and a UUID-aware index type helps. For most applications the trade-off - collision-free keys generated anywhere - is well worth it.
Can two generated UUIDs be the same?
Theoretically yes, practically no. With 122 random bits you would need to generate on the order of a quintillion values to reach a 50% chance of any collision. For real systems the risk is negligible.
Why not just use Math.random?
Math.random is predictable. Its output can be reconstructed with enough samples, and two processes with the same seed produce identical streams. IDs built from it are guessable - a real problem if they back session tokens or object keys. Crypto-grade randomness is the safe baseline.
Is anything uploaded when I generate?
No. UUIDs are generated in your browser from the platform's secure random source. Nothing is transmitted, stored or logged.
Can I use a UUID as a database primary key?
Yes - that is one of its most common jobs. The trade-off is index locality: random values fragment B-tree inserts on very large tables. Storing the compact binary form and using a UUID-aware index mitigates it, and the benefit of collision-free keys generated anywhere usually outweighs the cost.
Data & Privacy
Your data stays in your browser. Nothing is uploaded.
- Processing
- Local
- Upload
- None
- Server Storage
- None
- Account
- Not required
Related Tools
JWT Decoder
Inspect the header, payload and claims of a JSON Web Token - decoded locally, never uploaded.
Security & Tokens
Hash Generator
Generate MD5, SHA-1, SHA-256, SHA-384 and SHA-512 digests of any text, in your browser.
Security & Tokens
Random String Generator
Generate secure random strings and passwords with control over length and character set.
Security & Tokens
HMAC Generator
Sign a message with a secret key using HMAC-SHA256 or HMAC-SHA512, right in your browser.
Security & Tokens
JWT Validator
Check a JWT's structure and time claims - signature is never verified, so the verdict is about usability, not authenticity.
Security & Tokens
Base64 Encode & Decode
Convert text to Base64 or decode it back, with an optional URL-safe mode - all in your browser.
Encoding & Conversion