Skip to content
EveryFix

UUID Generator

The UUID Generator creates cryptographically-random version-4 UUIDs (RFC 4122) — the universally-unique identifiers used for database keys, API tokens, and record IDs. Generate up to 100 at once, toggle hyphens and uppercase, and copy any one or the whole batch. Because each ID is generated independently from random bits rather than a shared counter, UUIDs let multiple servers or services mint unique identifiers at the same time without checking in with a central database. Keep in mind version-4 UUIDs are randomly ordered, not sequential — if you need IDs that also sort chronologically, look at newer schemes like UUID v7 instead.

Beginner⏱ 20 secondsUpdated 2026-07-08

    Generates cryptographically-random version-4 UUIDs (RFC 4122) right in your browser — nothing is sent to a server, so every ID stays private. Up to 100 at a time.

    How This Tool Works

    Choose how many UUIDs you want and whether to include hyphens or uppercase letters, then press Generate. Copy any single UUID or the whole list with one click.

    Formula & Method

    A version-4 UUID is 122 random bits (with 6 fixed version/variant bits) shown as 32 hexadecimal digits in the pattern 8-4-4-4-12. The randomness comes from your browser’s cryptographic random number generator.

    Example Calculation

    Press Generate with a count of 5 to get five unique IDs like “3f2a9c14-8b7e-4d5a-9f10-2c6b1e8a4d33”, ready to paste into your database or code. Seeding a test database with 20 fake user records? Set the count to 20 and copy the whole batch at once, one UUID per line, straight into your seed script.

    Please note: This calculator provides estimates for general informational purposes only. Results may not be accurate for every situation — use your judgment and consult a relevant professional when it matters.

    About the UUID Generator

    Software constantly needs names for things that must never clash: a customer record, an uploaded file, a message in a queue, a browser session, a row created offline on a phone. The classic way to hand out identifiers is a counter in one database, but a counter needs a single authority that everyone has to ask. A UUID, short for universally unique identifier, removes that bottleneck. Any machine can invent one on its own, at any time, and the odds that two machines ever pick the same value are so small that nobody checks.

    This tool produces version 4 UUIDs, the random variety defined in RFC 4122. Out of the 128 bits in a UUID, 6 are fixed to mark the version and variant, leaving 122 bits chosen by your browser's cryptographic random generator. They are displayed as 32 hexadecimal digits in groups of 8-4-4-4-12, such as 3fa73e40-e967-46bf-9d62-988d4e4ee1a1. You can make up to 100 at a time, remove the hyphens, switch to uppercase, copy one, or copy the whole list.

    Developers use these values for database keys, correlation IDs in logs, test fixtures, file names, and idempotency keys for payment requests. Because the list is created in your browser, nothing is sent to a server. A version 4 UUID is an identifier, not a secret and not a sortable timestamp, and the sections below explain the practical consequences of each fact so you pick the right tool for each job.

    When to Use It

    Seeding a development database

    A developer needs 50 primary keys for sample rows. Set How many to 50, leave hyphens on, press Generate, then Copy all and paste the list, one value per line, into a SQL insert script or a spreadsheet column. Every key is independent, so the sample data can be merged with real data later without clashes.

    Creating idempotency or correlation keys

    When an API retries a payment or an order request, a client-generated unique key lets the server recognize the repeat. A tester needs a fresh one for each manual call, so a single UUID is generated and copied into the request header. The same pattern works for tracing one request through several services in the logs.

    Naming uploaded files without collisions

    Storing user uploads under their original names causes overwrites and leaks personal information in filenames. Generating a UUID for each file gives a name that is unique, contains no private data, and is safe in URLs when hyphens are kept; remove them if your storage system dislikes punctuation.

    Building offline-first apps

    A mobile app lets people create records without a connection and sync later. If each device uses a counter, two phones will both create record number 7. Generating a UUID on the device at creation time lets every record keep the same identity when it is uploaded, and no server round trip is required.

    How to Use It, Step by Step

    1. Look at the "How many" box, which starts at 5. Type a whole number from 1 to 100. Values above 100 are reduced to 100, and anything that is blank, zero, or not a number gives a single UUID.
    2. Tick or clear the Hyphens box. It is ticked by default, which gives the standard 36-character form. Clear it for a 32-character string with no separators, which some databases and file systems prefer.
    3. Tick or clear Uppercase. It is cleared by default, giving lowercase hex digits, which is the form most libraries and standards emit. Uppercase is common in some Microsoft tools.
    4. Press Generate to create a fresh batch. A first batch of five is created automatically when the page loads, so there will always be something to copy right away.
    5. Changing the Hyphens or Uppercase options after generating re-formats the same list immediately; it does not create new identifiers. Only the Generate button makes new ones, and that replaces the previous list.
    6. Press the small copy icon at the end of a row to copy that single UUID, or press "Copy all" to copy the whole list with one value per line, in the format currently selected.
    7. Paste the values where you need them and keep a note of which ones you used, because there is no history: once you press Generate again, the earlier list is gone.

    Understanding Your Results

    Each row is a version 4 UUID. You can verify this by eye. In the standard hyphenated form, the first digit of the third group is always 4, which marks the version, and the first digit of the fourth group is always one of 8, 9, a, or b, which marks the RFC 4122 variant. Everything else is random. With hyphens off, the same facts hold for characters 13 and 17 of the 32-character string. If a value fails these checks, it did not come from a standard version 4 generator.

    Formatting options change only how a value is displayed, not what it is. Uppercase and lowercase forms are the same identifier, and hyphens are only punctuation, so 3fa73e40-e967-46bf-9d62-988d4e4ee1a1 and 3FA73E40E96746BF9D62988D4E4EE1A1 are equal. When storing or comparing, normalize to one form, or better, store the 16 raw bytes your database offers, and compare case-insensitively.

    Uniqueness is statistical, not guaranteed, but the numbers are extreme. With 122 random bits there are about 5.3 x 10^36 possible values. Generating 100 UUIDs in a batch gives a collision probability around 10^-33, far below the chance of a hardware fault. The real risk is not collisions but misuse: a weak random source, copying one value into many places, or assuming that a UUID is secret or ordered when it is neither.

    More Worked Examples

    Reading a standard batch

    Scenario: How many: 3, Hyphens ticked, Uppercase cleared, then Generate.

    Three rows appear, each 36 characters long: 32 hex digits and four hyphens. A typical value is 3fa73e40-e967-46bf-9d62-988d4e4ee1a1. The third group begins with 4 and the fourth group begins with 8, 9, a, or b; in this sample they are 46bf and 9d62. The values differ every time you press Generate and cannot be predicted from earlier ones, so your own rows will be different. Copy all produces three lines of text with a line break after each, ready to paste.

    Changing the format without changing the ID

    Scenario: Take 3fa73e40-e967-46bf-9d62-988d4e4ee1a1; clear Hyphens, then tick Uppercase.

    With hyphens cleared, the row shows 3fa73e40e96746bf9d62988d4e4ee1a1, which is 32 characters. Ticking Uppercase on top of that gives 3FA73E40E96746BF9D62988D4E4EE1A1. These are three spellings of the same identifier, and the tool never regenerates the value when you flip these options. If you copy a row after changing the options, the copy contains the displayed form. Press Generate only when you want entirely new values.

    How the count box treats unusual entries

    Scenario: Type 250, 0, abc, 7.9, and a value with spaces around it, such as 12.

    The text is read as a whole number and kept between 1 and 100. Typing 250 produces 100 UUIDs, since 100 is the maximum. Typing 0 or abc produces one UUID, because a non-positive or non-numeric value falls back to 1. Typing 7.9 produces 7, since the decimal part is dropped, and a value with surrounding spaces such as 12 produces 12. The box continues to show what you typed rather than the adjusted number, so count the rows when you need to be certain.

    Tips for Better Results

    • If you need more than 100 values, press Generate, copy the batch, and repeat. Each batch is independent, so pasting several together is safe.
    • Store UUIDs in your database's native uuid type, if it has one, instead of as 36-character text. This halves the storage and speeds up comparisons.
    • When using random UUIDs as primary keys in a large indexed table, expect scattered inserts. If insert speed matters at scale, consider a time-ordered scheme such as UUID version 7, or add a separate sequential column for ordering.
    • Keep hyphens in anything that humans will read or paste into URLs. They make a long value much easier to check by eye, and most libraries expect the hyphenated form.
    • Do not parse meaning out of a version 4 UUID. It carries no time, machine, or user information, so use a separate created-at column for that.
    • Test your parsers with both cases and both forms. Real-world systems send uppercase, lowercase, hyphenated, and bare values, and your code should accept all of them.

    Common Mistakes to Avoid

    • Using a UUID as a password, session token, or API secret by default. It is unpredictable, but it is designed to be an identifier that is often logged and displayed; use a purpose-built token generator for secrets.
    • Expecting UUIDs to sort by creation time. Version 4 values are fully random, so their alphabetical order has no relation to when they were made.
    • Comparing UUID strings without normalizing case or hyphens. 3FA7... and 3fa7... are the same identifier, but a naive text comparison treats them as different.
    • Regenerating when you meant to reformat. Pressing Generate replaces the list with new values; use the Hyphens and Uppercase boxes if you only want a different appearance of the same IDs.
    • Assuming you can recreate a lost value later. Nothing is stored, and the earlier list disappears on the next Generate or page reload, so copy what you need first.

    Assumptions and Limits

    • Values come from the browser's cryptographic random generator through crypto.randomUUID when it is available, or from random bytes with the version and variant bits set by hand when it is not. Both yield valid version 4 UUIDs.
    • Uniqueness is probabilistic. For practical purposes collisions do not happen with a healthy random source, but no tool can offer an absolute guarantee, so systems that depend on uniqueness should still enforce it, for example with a database constraint.
    • The tool produces version 4 only. It does not generate time-based version 1 or version 7 UUIDs, namespace-based version 3 or 5, or sequential GUIDs.
    • Nothing is stored or transmitted. That also means there is no history or undo, and it is your responsibility to save any values you want to keep.

    Key Terms

    UUID
    A universally unique identifier, a 128-bit value usually written as 32 hexadecimal digits in groups of 8-4-4-4-12, designed to be unique without central coordination.
    GUID
    Globally unique identifier, Microsoft's name for the same kind of 128-bit value. In practice, GUID and UUID are interchangeable.
    Version 4
    The UUID version that fills nearly all of its bits with random data. The only fixed parts are the version digit 4 and the variant bits.
    Collision
    Two independently generated identifiers that happen to be identical. With 122 random bits it is astronomically unlikely.
    Idempotency key
    A unique value sent with a request so the server can recognize a retry and avoid doing the same action twice.

    Frequently Asked Questions

    What version of UUID is this?+

    Version 4 — the random variant defined in RFC 4122. It’s the most common choice for database keys and API identifiers.

    Are these UUIDs truly unique?+

    Version-4 UUIDs have 122 random bits, so the odds of a collision are astronomically small — for practical purposes they’re unique.

    Are the UUIDs generated privately?+

    Yes — they’re created locally with your browser’s crypto API and never sent anywhere, so they’re safe to use as secrets or keys.

    What’s the difference between a UUID and a GUID?+

    They’re the same thing under different names — GUID (Globally Unique Identifier) is Microsoft’s term for the same 128-bit format standardized as UUID in RFC 4122. Any UUID generated here works equally well as a GUID.

    Can two UUIDs generated here ever collide?+

    In theory yes, in practice no — a version-4 UUID has 122 random bits, giving about 5.3 × 10³⁶ possible values. You'd need to generate roughly a billion UUIDs every second for about 85 years before there's even a 50% chance of a single collision anywhere in that set.

    Is a random UUID a good database primary key?+

    It works well for uniqueness and for generating IDs in many places without coordination, but it has a cost. Random values land in arbitrary positions in an index, which can slow inserts and bloat large tables compared with sequential numbers. Many teams accept this, others use time-ordered UUID variants or store a separate sequential number for ordering. Store them in a native uuid column when your database provides one.

    How can I tell that a UUID is version 4?+

    Look at the hyphenated form. The first digit of the third group is the version number, so a version 4 UUID has a 4 there. The first digit of the fourth group shows the variant and is always 8, 9, a, or b for standard UUIDs. In 3fa73e40-e967-46bf-9d62-988d4e4ee1a1 those are the 4 in 46bf and the 9 in 9d62. The rest is random.

    Can I use a UUID as a password or API key?+

    It is not a good habit. A version 4 UUID from a cryptographic source has 122 unpredictable bits, so guessing one is infeasible, but the format is built to be an identifier. Identifiers are printed in logs, URLs, and error messages, and are widely shared. Use a dedicated secret or token generator for credentials, which can give you more bits, a suitable alphabet, and expiry or rotation.

    Are uppercase and lowercase UUIDs the same?+

    Yes. Hex digits are case-insensitive, so the same identifier can be written either way, with or without hyphens. The standard recommends emitting lowercase, while some Microsoft tools show uppercase. The risk is in software that compares them as plain text. Normalize both sides to one form before comparing, or convert to the 16-byte binary representation, which has no case at all.

    Why do I get a different list every time, and can I get the same one again?+

    Every press of Generate draws new random bits, so earlier values cannot be reproduced, and there is no seed to set. If you need a repeatable value, such as the same ID for the same input every time, you want a name-based UUID (version 5) or a hash instead. For random IDs, copy them as you go, since the list is replaced on each press.

    Found this useful? Share it

    Help someone else out — or link to it from your own site.

    Link to this tool

    Writing about uuid generator? Paste this on your site to link here.

    <a href="https://everyfix.net/tools/uuid-generator/">UUID Generator</a> by <a href="https://everyfix.net">EveryFix</a>