UUID Validator & Decoder (v7 Timestamp & Batch Inspector)
Validate and decode single or bulk UUIDs (v1-v8, Nil, Max). Extract embedded UUIDv7 UTC timestamps, verify RFC 9562 variant bits, and check batch duplicates and sorting.
Open toolUUIDv7 Generator
Generate RFC 9562 Version 7 (`UUIDv7`) identifiers locally in your browser with explicit 48-bit Unix millisecond timestamps, selectable 12-bit monotonic sub-millisecond counters (`rand_a`), lexicographical sort verification, and instant TXT, JSON, or SQL export.
Free to useNo sign-upRuns in your browser
Enter your details
Enter the inputs, then select Generate UUIDv7 Batch.
Your result
Enter your details
Result will appear here
How the Browser-Local UUIDv7 Generator Works
Unlike `crypto.randomUUID()`—which only produces purely random Version 4 UUIDs—this tool builds a 16-byte (`128-bit`) array directly in your browser using `Date.now()` (or your custom timestamp) and the Web Crypto CSPRNG (`crypto.getRandomValues`).
Bytes[0..5] = BigEndian48(unix_ts_ms); Byte[6] = 0x70 | (rand_a >> 8); Byte[7] = rand_a & 0xFF; Byte[8] = 0x80 | (rand_b_0 & 0x3F).
Verifies after generation that `list[i] < list[i+1]` holds across the entire batch in standard ASCII/byte sort order.
RFC 9562 UUIDv7 128-Bit Field Layout & Ordering Reference Table
Bit-by-bit structure of a 128-bit Version 7 UUID per IETF RFC 9562 Section 5.7 and Appendix A.6.
| Field Name | Bit Range (Width) | Hex Character Positions | Encoding & Ordering Role |
|---|---|---|---|
| `unix_ts_ms` | Bits 0–47 (48 bits) | Chars 1–12 (`xxxxxxxx-xxxx`) | Unsigned big-endian Unix epoch timestamp in milliseconds (`~8,925 years` range). |
| `ver` | Bits 48–51 (4 bits) | Char 15 (`7`) | Fixed binary `0111` (`0x7`) identifying RFC 9562 Version 7. |
| `rand_a` | Bits 52–63 (12 bits) | Chars 16–18 (`xxx`) | 12-bit sub-millisecond monotonic counter (`0–4,095`) or CSPRNG bits. |
| `var` | Bits 64–65 (2 bits) | Char 20 (`8`, `9`, `a`, or `b`) | Fixed binary `10` specifying the RFC 9562 / RFC 4122 variant. |
| `rand_b` | Bits 66–127 (62 bits) | Chars 20–36 (low 62 bits) | 62 bits of cryptographic randomness (`crypto.getRandomValues`) for collision resistance. |
How to Generate and Verify Time-Ordered UUIDv7s
Create single IDs, bulk database fixtures, or deterministic timestamp test cases in three steps.
Set batch size and timestamp source
Enter how many UUIDs you need (`1` to `1,000`) and choose either the live UTC millisecond clock or a fixed ISO-8601 / epoch-ms timestamp for reproducible unit tests.
Choose same-millisecond ordering behavior
Keep 'Monotonic 12-bit Counter in rand_a' enabled when generating batches that must sort strictly in creation order even when minted within the same millisecond.
Verify sort order and export as TXT, JSON, or SQL
Click Generate UUIDv7 Batch to inspect the embedded timestamp, confirm `100% Monotonic Ordered` status, and copy or download the output.
Worked examples for UUIDv7 Generator
Compare baseline and alternative runs for UUIDv7 Generator before exporting the result.
Baseline example
Generate RFC 9562 UUIDv7 identifiers locally in your browser. Supports bulk generation (1-1,000), embedded timestamp inspection, monotonic counter ordering, and JSON/SQL export.
Comparison scenario
Bytes[0..5] = BigEndian48(unix_ts_ms); Byte[6] = 0x70 | (rand_a >> 8); Byte[7] = rand_a & 0xFF; Byte[8] = 0x80 | (rand_b_0 & 0x3F).
Boundary check before exporting
Verifies after generation that `list[i] < list[i+1]` holds across the entire batch in standard ASCII/byte sort order.
How to interpret the UUIDv7 Generator output
Review the calculated output alongside your entered parameters and unit conventions.
Verifies after generation that `list[i] < list[i+1]` holds across the entire batch in standard ASCII/byte sort order.
Input limits, assumptions, and related tools
Check the model scope and boundary conditions before applying the numbers to a real project.
Bytes[0..5] = BigEndian48(unix_ts_ms); Byte[6] = 0x70 | (rand_a >> 8); Byte[7] = rand_a & 0xFF; Byte[8] = 0x80 | (rand_b_0 & 0x3F). Verifies after generation that `list[i] < list[i+1]` holds across the entire batch in standard ASCII/byte sort order.
vCard Splitter
Split multi-contact .vcf vCard files into individual BEGIN:VCARD...END:VCARD blocks and extract FN, TEL, and EMAIL contact tables locally in your browser.
Open tool
Find Command Generator
Generate Linux and macOS find commands with -name/-iname globs, file type (-type f/d), size, modification time (-mtime), -maxdepth, and -exec actions.
Open toolMore free tools to try
Choose another tool for your next calculation, conversion, or text task.
Adler32 Calculator
Compute the Adler-32 checksum of UTF-8 text.
Open tool
Plist to JSON Converter
Convert Apple XML .plist (Property List) files to formatted or minified JSON online, mapping <dict>, <array>, <string>, <integer>, <real>, and <true/>/<false/>.
Open tool
Rsync Command Generator
Generate rsync commands for local and remote SSH file synchronization with -avzP, custom SSH port, --delete, --exclude patterns, and --dry-run safety.
Open tool
SSH Config Generator
Generate ~/.ssh/config Host blocks with HostName, User, Port, IdentityFile, ProxyJump bastion host, LocalForward port forwarding, and ServerAliveInterval.
Open toolFrequently Asked Questions
Answers about using UUIDv7 Generator and understanding its results.
Does JavaScript's built-in crypto.randomUUID() generate UUIDv7?
No. The W3C Web Cryptography API specification defines crypto.randomUUID() exclusively for Version 4 (pseudorandom) UUIDs. A genuine UUIDv7 generator must assemble a 16-byte buffer placing the 48-bit big-endian Unix millisecond timestamp in bytes 0-5, setting version nibble 0b0111 (7) in byte 6, setting RFC 9562 variant bits 0b10 in byte 8, and filling the remaining bits from crypto.getRandomValues().
Are two UUIDv7 values generated in the same millisecond guaranteed to sort in creation order?
Only if the generator implements a sub-millisecond monotonic counter (RFC 9562 Section 6.2) and both IDs are minted by the same generator state. In 'Monotonic 12-bit Counter' mode, this tool seeds the 12-bit rand_a field randomly at the start of a millisecond and increments it by +1 for each additional UUID in that same millisecond (up to 4,096 IDs/ms). In 'Pure CSPRNG 74-bit' mode, or across two independent servers/tabs in the same millisecond, order within that millisecond is random.
Why do database engineers prefer UUIDv7 over UUIDv4 for B-tree primary keys?
UUIDv4 scatters 122 random bits across the entire 128-bit space, so every new INSERT lands on a random B-tree leaf page, causing frequent 50/50 page splits, index fragmentation, and buffer-pool cache misses once the index exceeds RAM. Because UUIDv7 places a 48-bit millisecond timestamp in the most significant bits, new rows append near the right edge of the B-tree index like a sequential BIGINT.
When should I still use UUIDv4 instead of UUIDv7?
Use UUIDv4 when the identifier is exposed in public URLs, invite tokens, or API responses where leaking the exact millisecond a user account, order, or document was created is a privacy or competitive risk.
Try your own values
Choose another tool for your next calculation, conversion, or text task.