Skip to content
BeeTools— Fast. Private. Free.

UUID Generator

Runs in your browser

Generate version 4 UUIDs in bulk using your browser’s cryptographic random source.

Developer Tools

Options

Up to 100 at a time.

0 identifiers

Version 4 · RFC 4122

    Generated with your browser’s cryptographic random source — crypto.randomUUID() where available, and crypto.getRandomValues() otherwise. Each identifier carries 122 bits of randomness. Nothing is transmitted or stored, so these are yours alone.

    Your data never leaves your device

    This tool runs entirely in your browser. Nothing you enter is uploaded, stored or logged by BeeTools.

    How to use the uuid generator

    1. Choose how many you need

      The slider goes from one to a hundred. A fresh batch is generated as soon as you release it.

    2. Pick the format

      The default — lowercase with hyphens — is the canonical RFC 4122 form and what most systems expect. Turn off hyphens for the 32-character form some databases prefer, or turn on braces for Windows registry and COM conventions.

    3. Copy what you need

      Use the button beside any single identifier, or Copy all for the whole batch as newline-separated text.

    4. Regenerate freely

      Every press produces an entirely independent batch. Nothing is reused between batches.

    Features

    • Cryptographically secure

      Draws from crypto.randomUUID() or crypto.getRandomValues(), never Math.random().

    • Up to 100 at once

      Generate a batch for seeding a database or filling a test fixture, and copy them all.

    • Every common format

      Lowercase or uppercase, hyphenated or the compact 32-character form, optionally in braces.

    • Copy one or copy all

      Each identifier has its own copy button, and the whole batch copies as newline-separated text.

    • Download the batch

      Save a generated set as a plain text file for scripting or import.

    • Never transmitted

      Identifiers are produced on your device and are not logged or stored anywhere.

    About this tool

    A UUID is a 128-bit identifier you can generate anywhere — on a laptop, on a phone, inside a database transaction — and still rely on being unique, without asking a central server to allocate it. That property is why they are everywhere: primary keys, request identifiers, idempotency keys, file names.

    Version 4 UUIDs get their uniqueness from randomness alone. Of the 128 bits, six are fixed to mark the version and variant, leaving 122 bits of pure entropy. The numbers involved are large enough to be worth stating plainly: you would need to generate a billion UUIDs per second for around 85 years before a single collision became more likely than not.

    That guarantee rests entirely on the quality of the random source, which is the one thing a generator can get wrong. This one uses crypto.randomUUID() where the browser provides it and falls back to crypto.getRandomValues() otherwise — both draw from the operating system's cryptographic entropy pool. Math.random() is never involved. That distinction is not academic: identifiers from a weak generator can be predicted, which turns a UUID used as a password-reset token or an unguessable file URL from a safeguard into a vulnerability.

    Generate up to a hundred at a time, in whichever form your target system wants — lowercase or uppercase, with or without hyphens, wrapped in braces for the Microsoft registry convention. Everything is produced in your browser and nothing is stored, so the identifiers you take away are yours alone.

    • Cryptographically secure. Draws from crypto.randomUUID() or crypto.getRandomValues(), never Math.random().
    • Up to 100 at once. Generate a batch for seeding a database or filling a test fixture, and copy them all.
    • Every common format. Lowercase or uppercase, hyphenated or the compact 32-character form, optionally in braces.
    • Copy one or copy all. Each identifier has its own copy button, and the whole batch copies as newline-separated text.
    • Download the batch. Save a generated set as a plain text file for scripting or import.
    • Never transmitted. Identifiers are produced on your device and are not logged or stored anywhere.

    Frequently asked questions

    What is a version 4 UUID?

    One whose bits are almost entirely random. Four bits are fixed to record the version and two more to record the variant, leaving 122 random bits. Other versions derive their values differently — version 1 from a timestamp and MAC address, versions 3 and 5 by hashing a name — but version 4 is the right default whenever you simply need an identifier that will not collide.

    Are these UUIDs guaranteed to be unique?

    Not guaranteed, but the probability of a collision is negligible in any realistic system. With 122 random bits you would need to generate roughly a billion per second for 85 years to reach a 50% chance of one duplicate. In practice the risk from a weak random source is many orders of magnitude larger than the risk from the mathematics, which is why the source matters more than the version.

    Can I use a UUID as a secret token?

    A version 4 UUID from a cryptographic source has 122 bits of entropy, which is comfortably more than a strong password, so it is acceptable for a password-reset link or an unguessable URL. Two cautions: never use a version 1 UUID for this, since it encodes a timestamp and MAC address and is therefore predictable; and remember UUIDs are routinely logged and put in URLs, so treat them as identifiers that happen to be unguessable rather than as credentials to be protected.

    Why not use Math.random()?

    Math.random() is a fast pseudo-random generator built for simulations and games. Its internal state can be reconstructed from a modest number of observed outputs, after which every future value is predictable. A surprising number of online UUID generators use it. crypto.getRandomValues() draws from the operating system’s entropy pool and is designed to resist exactly that attack.

    What is the difference between a UUID and a GUID?

    Nothing, in practice. GUID is Microsoft’s name for the same 128-bit identifier, and the two terms are interchangeable. The only visible difference is presentational: Microsoft tooling often wraps them in braces and sometimes uses uppercase, both of which this tool can produce.

    Should I use a UUID as a database primary key?

    It depends on the engine. UUIDs let you generate keys client-side and merge datasets without collisions, which is genuinely useful. The cost is that random values scatter inserts across the index rather than appending to the end, which fragments B-tree indexes and hurts write throughput at scale. If that matters to you, look at UUID v7, which puts a timestamp in the high bits to restore ordering while keeping the rest random.

    Related tools

    Tools that pair well with this one.