A UUID (Universally Unique Identifier) generator creates 128-bit identifiers, and this free, browser-based UUID Generator produces cryptographically random RFC 4122 version 4 values in batches of 1 to 100.
Use it when you need one identifier or a batch for database records, distributed applications, idempotency keys, trace or correlation IDs, object names, or API requests. The UUID Generator runs entirely in your browser: it obtains random bits through the Web Crypto API's getRandomValues method and does not transmit generated values to a server.
Version 4 UUIDs are useful because they do not require a central allocator, timestamp, MAC address, or namespace. Several devices can create identifiers independently, which supports distributed systems and offline workflows.

Generate a UUID batch in four steps
- Set the count. Open the tool and enter how many identifiers you need. The supported range is 1 to 100, so a count of 1 creates a single UUID and 100 creates the largest available batch.
- Set the text format. Use the uppercase toggle when the destination expects A–F, and use the remove-hyphens toggle when it expects one continuous 32-character hexadecimal value. Leave a control off when that variation is not needed.
- Generate the values. Click Generate to create a fresh set of random RFC 4122 version 4 UUIDs. The operation stays in the current browser tab.
- Copy the output. Copy any single UUID from the list or select Copy all for the whole batch. Paste the selected text into the schema, test fixture, request, or file where it belongs.
The count limit matters when planning bulk data: this workflow cannot generate more than 100 UUIDs in one batch. For a single code path, use 1; for a larger fixture set, choose the largest count that fits the test data.
The format toggles are presentation controls. They do not change the version, random payload, or uniqueness of the generated identifiers.
Read a version 4 UUID correctly
A canonical UUID is written as 32 hexadecimal digits in an 8-4-4-4-12 pattern. An example is f47ac10b-58cc-4372-a567-0e02b2c3d479. The hyphens separate groups for readability; they are not extra identifier data.
Version 4 is more structured than a generic random hexadecimal string. The RFC 4122 specification defines the UUID format, and RFC 9562 updated it in 2024. A generated value carries a version field and a variant field in addition to its random payload.
| UUID component | Defined value | Practical meaning |
|---|---|---|
| Total width | 128 bits | A fixed-length identifier represented by 32 hexadecimal digits. |
| Canonical layout | 8-4-4-4-12 | The hexadecimal digits are separated into five groups. |
| Version | 4 | The 13th hexadecimal digit is always 4 for a version 4 UUID. |
| Variant | 8, 9, a, or b | The 17th hexadecimal digit carries the RFC-defined variant. |
| Random payload | 122 bits | The remaining bits are supplied by a cryptographically secure random source. |
This means a canonical value has 4 at the 13th hexadecimal digit and one of 8, 9, a, or b at the 17th. The remaining 122 bits carry the random material. Because version 4 does not encode a timestamp, you cannot read creation time from the UUID itself.
Match the format your system expects
The same identifier can be represented in several text forms. Choose the form accepted by the destination rather than applying formatting by habit.
| Output option | Text form | Best fit |
|---|---|---|
| Canonical representation | Lowercase hexadecimal digits in 8-4-4-4-12 groups | Systems expecting the standard grouped UUID format. |
| Uppercase toggle | The grouped UUID with A–F capitalized | Destinations that explicitly require uppercase hexadecimal letters. |
| Remove-hyphens toggle | 32 hexadecimal digits without separators | Compact inputs that expect continuous UUID text. |
Uppercasing and removing hyphens change only the text form, never the underlying 128-bit value or its uniqueness. They also do not add randomness or security.
If a system accepts several representations, parse each UUID into its standardized value before comparing it with another identifier. Comparing raw strings can report a difference between uppercase, lowercase, or hyphenated forms even though they identify the same 128-bit value.
Put UUID v4 to work across a development stack
UUID v4 is a good fit when independent systems need to create IDs without asking a central service for the next number.
- Database primary keys: Use one UUID as the primary-key value for a record when you want a globally unique, coordination-free identifier. The value does not reveal when the record was created.
- Distributed and offline-first systems: Let separate services, workers, or offline clients mint their own IDs. No shared allocator has to be available at the moment a record is created.
- Idempotency keys: Create a distinct key for each logical operation and reuse that same key when retrying the operation. This lets a receiving service recognize the retry as the same request.
- Correlation and trace IDs: Attach a UUID to a request or operation so related entries can be found across logs or services.
- File and object names: Give uploaded or generated objects a unique name without depending on a single machine's counter.
- API request identifiers: Expose a request identifier in responses or diagnostics so support and engineering teams can connect a report to the relevant request.
If write locality from chronologically ordered keys is the priority, UUIDv7 is the newer time-ordered option. This browser tool creates v4 only, so it does not satisfy a requirement that explicitly calls for v7.
Keep access control separate from identifier generation. A UUID can be unguessable, but once it appears in a URL, log, or response, anyone who sees it can see it. Do not treat the identifier itself as proof that a request is authorized.
If IDs must be minted automatically inside an application, the dedicated guide to generate UUIDs in JavaScript covers the code path rather than manual copy-and-paste.
Keep generation private and cryptographically random
The 122 random bits come from the platform's cryptographically secure random number generator through the Web Crypto API's getRandomValues method. This is not the weak, predictable Math.random approach used by some quick scripts. A CSPRNG keeps generated values statistically independent and unguessable.
Every UUID is created locally in the browser tab. The tool does not upload generated values or copied text, so there is no server-side generation step and no transmission of the identifier as part of using the page.
That local workflow makes the generator suitable for internal identifiers and production secrets that need random, unguessable values. Once you paste a value into another system, that destination controls its storage and transmission. Sensitive identifiers should not be placed in URLs or logs if their exposure would be a problem.
Know the boundaries before deployment
The generator is deliberately focused, but those boundaries affect how you should use its output.
- Batch size: The supported count is 1 to 100 per generation. Plan bulk fixtures around that limit.
- UUID version: Only random version 4 identifiers are produced. The tool does not generate timestamp-based, name-hash, or time-ordered variants.
- Uniqueness: The 122 random bits make collisions negligible for real-world volumes, but not mathematically impossible. Keep ordinary uniqueness checks at the storage boundary.
- Ordering: UUID v4 contains no timestamp. Sorting or indexing by time requires a separate design choice.
- Formatting: Uppercase and no-hyphen output are equivalent text forms, not different IDs. Downstream validators still need to accept the format you supply.
Run a preflight before shipping
A short review catches format and design mismatches before generated values reach a database or client.
- Confirm the version. For canonical output, check that the 13th hexadecimal digit is 4 and the 17th is one of 8, 9, a, or b. If you use no-hyphen output, validate it with the receiving system's parser rather than changing it by hand.
- Confirm format acceptance. Parse one generated value with the destination's UUID parser or schema and verify that its uppercase and hyphen rules match exactly.
- Define key reuse. For idempotency keys, store or carry one key per logical operation and reuse it only for retries of that operation.
- Avoid time assumptions. Do not use UUID text to infer age, sequence, or creation order; keep an explicit timestamp when the application needs one.
- Review exposure. Decide whether identifiers can appear in URLs, logs, analytics, or client-visible responses, and keep authorization checks independent of ID possession.
For a deeper look, see How to Remove Lumot: App, Account, or BOM?.