UUID Generator Online Free
Generate UUID v1, v4, and v5 instantly. Bulk generate up to 1000 UUIDs at once, choose your format, validate existing UUIDs, and export as a list. Everything runs in your browser.
UUID v1, v4, and v5, generated to spec with real cryptographic randomness
Three UUID versions from RFC 4122 are implemented here, each with a genuinely different generation method, not just a different label slapped on the same random bytes. Version 4 uses the browser’s cryptographically secure random number generator. Version 1 encodes a real timestamp. Version 5 hashes a namespace and a name through SHA-1, implemented from scratch in plain JavaScript, so the same namespace and name always produce the identical UUID. Nothing is generated on a server; every byte is produced locally.
Version 4: random, and where the randomness comes from
The tool calls crypto.getRandomValues(), the Web Crypto API’s cryptographically secure random source, to fill 16 bytes. It does not use Math.random(), which is not specified to be cryptographically secure and should never back an identifier meant to be unguessable. Two bytes are then adjusted to encode the version and variant.
crypto.getRandomValues(new Uint8Array(16)) produces 128 bits of cryptographically secure randomness.
0x0f then OR’d with 0x40, forcing its high nibble to 4. This is the bit pattern that marks a UUID as version 4 to any parser that reads it.
0x3f then OR’d with 0x80, setting the two most significant bits to 10, which marks this as an RFC 4122 variant UUID (as opposed to the older, rarer NCS or Microsoft GUID variants).
Version 1: time-based, with a real 100-nanosecond timestamp
Version 1 UUIDs embed the moment of creation. The tool takes Date.now(), converts milliseconds to 100-nanosecond intervals (the unit the UUID spec actually uses), and adds the fixed offset between the Unix epoch of 1970 and the UUID epoch of October 15, 1582, the date the Gregorian calendar was adopted. That combined 60-bit timestamp is then split across the time-low, time-mid, and time-high fields, with the version nibble stamped into the high field. The remaining bytes, which the full spec would derive from a MAC address and a clock sequence, are filled with secure random bytes here instead, since a MAC address is not something browser JavaScript has access to and should not be exposed even if it were.
Version 5: deterministic, via namespace and name
Version 5 is the only one that is not random at all. It takes a namespace UUID and a name string, UTF-8 encodes the name, concatenates it after the namespace’s 16 raw bytes, and runs the result through SHA-1. The tool implements the full SHA-1 algorithm by hand, message padding, the 80-round main loop, and the five working variables, entirely in JavaScript rather than pulling in the Web Crypto SubtleCrypto.digest API. The first 16 bytes of that 20-byte hash become the UUID, with the version nibble set to 5 and the variant bits set to the standard RFC 4122 pattern, same as the other two versions.
| Version | Source of bytes | Deterministic? |
|---|---|---|
| v1 | Timestamp (60-bit, 100ns units) + random bytes standing in for node/clock sequence | No, changes every call |
| v4 | crypto.getRandomValues(), fully random | No |
| v5 | SHA-1 hash of namespace bytes + UTF-8 name bytes | Yes, same inputs always produce the same UUID |
Formatting and bulk generation
Format options
Uppercase hex, hyphens stripped to a plain 32-character string, or wrapped in curly braces, the format Windows COM and some .NET APIs expect for GUIDs.
Bulk generation
Up to 1,000 UUIDs per batch, each generated independently with the same version logic, joined by newlines or commas.
Format validator
Checks a pasted string against four regex patterns (v1, v4, v5, and a generic pattern) to report which version, if any, it structurally matches.
UUID specifications and libraries
- RFC 4122 is the specification defining every UUID version, field layout, and the version/variant bit patterns this tool stamps into each identifier.
- MDN: Crypto.getRandomValues() documents the secure random source backing version 4 generation.
- RFC 3174: US Secure Hash Algorithm 1 (SHA-1) is the hashing algorithm implemented by hand for version 5 UUIDs.
- uuid (npm package) is the standard JavaScript library for server-side or Node.js UUID generation if you need this outside a browser context.
Where unique identifiers are needed
Generating primary keys for a new database table, creating unique request or trace IDs for logging and debugging, producing deterministic identifiers for the same resource across different systems using version 5 with a shared namespace, seeding test fixtures with realistic looking IDs, and validating that an ID pasted from a bug report is actually a well formed UUID before searching for it in a database.
FAQ: UUID Generator Online Free
Yes. No signup required and no limits. Generate as many UUIDs as you need, forever free.
UUID v4 is random and the most widely used. UUID v1 is based on the current timestamp, making it sortable. UUID v5 is deterministic: given the same namespace and name, it always produces the same UUID, which is useful for reproducible identifiers.
UUID v4 generation uses crypto.getRandomValues, the browser API backed by the operating system cryptographic random number generator. This is the same source used by security-sensitive software.
Yes. Enable the No hyphens option to get a compact 32-character hex string. Some databases and APIs prefer this format.
UUID v5 creates the same UUID every time for a given namespace and name. This makes it useful for content-addressed identifiers, deduplication, or anywhere you need a stable ID derived from a known input, like a URL or domain name.
Scroll to the Validate a UUID section, paste any UUID into the input field, and click Validate. The tool checks the format and reports which version it is.
From the blog
Deep dives on the things these tools touch
Minification, UUID collisions, diffing API responses, and the other questions that come up around this toolset.
