UUID Parser & Decoder

Parse RFC 9562 UUIDs locally in your browser.

No uploadsNo sign-upInstant results
v1–v8 · Nil · Max DecoderExtracts v1, v6 & v7 Timestamps100% Local • Zero Uploads
Inspect UUIDs
Offline engine ready100% private in-browser workspace • Zero cloud uploads
100% Private • Zero Server File Uploads

Why Use Utiliome's Free UUID Parser & Decoder?

Built from the ground up for strict privacy, instant execution, and zero friction. No subscriptions, paywalls, or account registrations required.

Embedded v1, v6 & v7 Timestamp Extraction

Converts 48-bit Unix Epoch millisecond fields in UUIDv7 and 60-bit 100-nanosecond Gregorian counters in UUIDv1 and UUIDv6 into exact ISO-8601 UTC timestamps and raw epoch integers.

Full RFC 9562 Bit-Field Breakdown

Inspects all 128 bits across octets 0 through 15, isolating the 4-bit version nibble (v1 through v8), special Nil and Max constants, variant bit prefix, 14-bit clock sequence, and 48-bit node ID.

Hexadecimal & 128-Bit Binary Layout

Renders canonical 8-4-4-4-12 hex alongside 16-byte octet groupings and bit-indexed binary segments so you can verify big-endian ordering, IEEE 802 multicast flags, and entropy bits.

Zero-Upload Client-Side Decoding

Executes all bitmasking and 64-bit BigInt epoch arithmetic directly in browser memory with zero network requests, keeping production primary keys, audit IDs, and session tokens private.

Utiliome vs Traditional Cloud Alternatives

Compare our local-first WebAssembly engine against legacy cloud tools.

Feature Utiliome (Local Browser) Legacy Cloud Converters
RFC 9562 Version Support (v1–v8, Nil, Max) Decodes v1, v3, v4, v5, v6, v7, v8, Nil (0000...), and Max (ffff...) UUIDs Recognizes legacy v1 and v4 only and labels v7/v6 as "Unknown version"
Timestamp Extraction (v1, v6 & v7) Reconstructs exact UTC ISO-8601 creation timestamps from 60-bit Gregorian & 48-bit Unix fields Cannot extract creation time from modern database-friendly UUIDv7 keys
128-Bit Field & Bit-Layout Visualizer Inspects variant bits (10xx), version nibble, clock sequence, and IEEE 802 node/MAC bits Outputs version number only without showing byte or bit breakdown
Privacy & Production ID Security 100% client-side bit inspection — production primary keys stay in your browser Submits database identifiers to external backend APIs
How it works

How to Use UUID Parser & Decoder in 3 Easy Steps

No software installation required. Everything runs directly inside your web browser.

1

Enter or Upload a UUID

Paste a canonical 36-character UUID, unhyphenated 32-character hex string, braced GUID, or URN-prefixed identifier into the input field, or drop a local text file.

2

Inspect Decoded RFC 9562 Fields

Review the extracted version (v1 through v8, Nil, or Max), RFC variant bit prefix, raw 128-bit hexadecimal and binary octets, and version-specific subfields.

3

Copy Timestamps or Structured Output

For time-ordered v1, v6, and v7 keys, copy the decoded ISO-8601 UTC creation timestamp, Unix millisecond epoch value, clock sequence, or structured JSON breakdown.

Decoding Time-Based UUIDs: Concrete Input and Output Walkthrough

Quick Answer: Parsing a UUID strips formatting delimiters, maps the 128-bit identifier into 16 big-endian octets, reads bits 48-51 for the version and bits 64-65 for the variant, and applies version-specific bitmasks to decode Unix Epoch milliseconds (v7) or 100-nanosecond Gregorian ticks, clock sequences, and node IDs (v1 and v6).

Time-based UUIDs store creation timestamps in two distinct epoch systems defined by RFC 9562: Unix Epoch milliseconds for UUIDv7 and 100-nanosecond Gregorian intervals since 1582-10-15T00:00:00Z for UUIDv1 and UUIDv6.

Example 1: Decoding a UUIDv7 Primary Key

Consider a database primary key generated with UUIDv7:

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f

The parser reads the first 48 bits (01941f297c7b) as an unsigned big-endian millisecond integer (1735689600123), verifies nibble 13 (7, binary 0111) and the top two bits of nibble 17 (9, binary 1001 -> variant 10), and separates rand_a (12 bits) from rand_b (62 bits):

{
  "canonical": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f",
  "version": 7,
  "versionLabel": "UUIDv7 (Unix Epoch Time-Ordered)",
  "variant": "RFC 9562 (10xx)",
  "timestamp": {
    "epochSystem": "Unix Epoch (1970-01-01T00:00:00Z)",
    "unixMilliseconds": 1735689600123,
    "iso8601Utc": "2025-01-01T00:00:00.123Z"
  },
  "fields": {
    "unix_ts_ms": "0x01941f297c7b",
    "ver": "0b0111 (7)",
    "rand_a": "0xa3c (12 bits)",
    "var": "0b10",
    "rand_b": "0x1f4e2b8d5c1a0e6f (62 bits)"
  }
}

Example 2: Decoding UUIDv1 vs Reordered UUIDv6

Both identifiers below encode the exact same Gregorian timestamp (0x1efc7d357fd0000 = 139549824000000000 ticks of 100 ns), clock sequence, and node ID, differing only in how the 60 timestamp bits are arranged across octets 0 through 7:

UUIDv1: 57fd0000-c7d3-11ef-aa1b-3d8f4a91c20e
UUIDv6: 1efc7d35-7fd0-6000-aa1b-3d8f4a91c20e

Reassembling time_hi (1ef), time_mid (c7d3), and time_low (57fd0000) from UUIDv1—or concatenating time_high (1efc7d35), time_mid (7fd0), and time_low (000) from UUIDv6—and subtracting the Gregorian-to-Unix offset (122192928000000000 ticks) yields the decoded field report:

{
  "canonical": "57fd0000-c7d3-11ef-aa1b-3d8f4a91c20e",
  "version": 1,
  "variant": "RFC 9562 (10xx)",
  "timestamp": {
    "gregorianTicks100ns": "139549824000000000",
    "unixMilliseconds": 1735689600000,
    "subMillisecondNanoseconds": 0,
    "iso8601Utc": "2025-01-01T00:00:00.000Z"
  },
  "clockSequence": {
    "hex": "0x2a1b",
    "decimal": 10779
  },
  "node": {
    "formatted": "3d:8f:4a:91:c2:0e",
    "multicastBit": 1,
    "nodeType": "Pseudorandom multicast node (RFC 9562 Section 6.10)"
  }
}

RFC 9562 Bit Layouts, Epoch Arithmetic, and Security Properties

Quick Answer: RFC 9562 defines a 128-bit big-endian layout where bits 48-51 encode versions 1 through 8 and bits 64-67 determine the variant. Only versions 1, 6, and 7 carry standardized timestamps; versions 3, 4, and 5 hold deterministic digests or CSPRNG entropy, while version 8 reserves 122 bits for opaque vendor-defined schemas.

Under RFC 9562 (which obsoleted RFC 4122 in May 2024), a UUID is an unsigned 128-bit value transmitted in network byte order (most significant bit numbered 0, least significant bit numbered 127).

Bit-Level Field Layouts Across Time-Based Versions

Bit Index:  0                   31 32       47 48  51 52        63
UUIDv1:    [      time_low (32)   | time_mid  | 0001 | time_hi(12)]
UUIDv6:    [     time_high (32)   | time_mid  | 0110 |time_low(12)]
UUIDv7:    [          unix_ts_ms (48 bits)    | 0111 | rand_a (12)]

Bit Index:  64 65 66            79 80                           127
UUIDv1/v6: [ 10  |  clock_seq(14) |          node (48 bits)       ]
UUIDv7:    [ 10  |               rand_b (62 bits)                 ]

Variant Prefixes and Boundary Constants

Octet 8 (bits 64-71, starting at the 17th hex digit) determines how the remaining bit layout is interpreted:

  • 0xxx (hex 0-7): Reserved for legacy Apollo NCS backward compatibility.
  • 10xx (hex 8, 9, a, b): Standard RFC 9562 variant used by UUIDv1 through UUIDv8.
  • 110x (hex c, d): Reserved for legacy Microsoft COM/DCOM GUID backward compatibility.
  • 111x (hex e, f): Reserved for future definition, except when all 128 bits are 1, which forms the Max UUID (ffffffff-ffff-ffff-ffff-ffffffffffff, RFC 9562 Section 5.10). Similarly, 128 zero bits form the Nil UUID (00000000-0000-0000-0000-000000000000, Section 5.9).

64-Bit Precision Pitfalls in Gregorian Epoch Math

A 60-bit Gregorian counter holds values around 1.39 * 10^17 ticks, exceeding IEEE-754 double-precision Number.MAX_SAFE_INTEGER (9,007,199,254,740,991 or 2^53 - 1) by more than an order of magnitude. Converting UUIDv1 or UUIDv6 timestamps using standard 64-bit floating-point numbers silently rounds off the lowest 4 to 5 bits (corrupting sub-millisecond ticks by up to 3.2 microseconds). Accurate decoding requires arbitrary-precision BigInt arithmetic using the exact offset of 141,427 days (122,192,928,000,000,000 ticks of 100 nanoseconds, 0x01b21dd213814000) between 1582-10-15T00:00:00Z and 1970-01-01T00:00:00Z. By contrast, UUIDv7's 48-bit unix_ts_ms maxes out at 281,474,976,710,655 ms (10889-08-02T05:31:50.655Z), fitting safely inside 53-bit integers.

Privacy and Metadata Leakage

Inspecting external UUIDs exposes operational metadata when time-based versions are used in public endpoints:

  • Hardware MAC vs Pseudorandom Node: In UUIDv1, if the least significant bit of octet 10 (the IEEE 802 unicast/multicast bit) is 0, the 48-bit node field frequently exposes the generating host's physical network interface MAC address and IEEE OUI vendor prefix. RFC 9562 Section 6.10 recommends setting this multicast bit to 1 with random node bytes (mandatory in UUIDv6 when no MAC is desired).
  • Creation Rate Inference: Publicly exposed v1, v6, and v7 identifiers disclose exact record creation timestamps, allowing observers to measure signup velocity or order volume between two IDs. For opaque public tokens, use random UUIDv4 (122 CSPRNG bits) instead.

UUID Parser vs UUID Validator vs Time-Ordered Generator: Which One Do You Need?

Quick Answer: Use the UUID Parser & Decoder when you need to inspect a single identifier's internal 128-bit fields, node ID, or embedded v1, v6, and v7 UTC timestamp. Use the UUID Validator to check syntax and filter thousands of candidate IDs in bulk, or the UUID v7, v6 & v1 Generator to mint new time-ordered keys.

Each tool in the Utiliome UUID suite targets a distinct stage of working with RFC 9562 identifiers:

Capability UUID Parser & Decoder (This Tool) UUID Validator UUID v7, v6 & v1 Generator
Primary Intent Inspect internal bit fields and decode embedded timestamps from an existing UUID Verify RFC 9562 syntax, version, and variant compliance across single or bulk lists Generate new time-ordered RFC 9562 UUIDs for database primary keys
Timestamp Handling Extracts ISO-8601 UTC dates, Unix ms, and 100-ns Gregorian ticks from v1, v6, and v7 Does not decode timestamps; verifies version nibbles and variant bit prefixes Encodes current or custom timestamps into fresh v7, v6, or v1 identifiers
Bit & Binary Inspection Full 128-bit binary layout, clock sequence, rand_a/rand_b, and IEEE 802 node flags Per-row version label (v1-v8, Nil, Max) and syntax failure diagnostics Formats newly minted keys as canonical hyphenated hex, raw hex, or JSON
Bulk Filtering & Export Focused single-key deep inspection Filters multi-line files or pasted logs and exports sanitized valid UUID sets Bulk-generates monotonic batches of time-ordered keys

Choosing the Right Workflow

  • Debugging an event log or primary key: Paste the identifier here to extract its exact UTC creation timestamp, check whether its node ID is a hardware MAC or multicast random address, and inspect its raw 128-bit layout.
  • Auditing or cleaning a dataset: Send CSV columns, log dumps, or API payloads to the UUID Validator to strip malformed strings, detect legacy Microsoft 110x GUIDs, and export canonical lowercase identifiers.
  • Creating new identifiers: Use the UUID v7, v6 & v1 Generator when you need B-tree-friendly time-ordered keys, or the UUID v4 Generator when you need non-temporal 122-bit CSPRNG identifiers with zero timestamp leakage.
FAQ

UUID Parser & Decoder FAQ and Technical Guide

Everything you need to know about using Utiliome's free online uuid parser.

Can you extract a creation timestamp from a UUID v4 or UUID v5?

No. A UUIDv4 contains 6 fixed version and variant bits and 122 bits of cryptographically random (CSPRNG) output, while UUIDv3 and UUIDv5 contain truncated MD5 or SHA-1 hashes of a namespace UUID and name string. None of them store time, clock sequence, or host metadata—only UUIDv1, UUIDv6, and UUIDv7 (plus legacy DCE Security v2 with coarse POSIX UID/GID substitutions) carry standardized creation timestamps.

Why do UUID v1 and UUID v6 decode to the exact same timestamp from different hex prefixes?

Both versions encode a 60-bit count of 100-nanosecond intervals elapsed since 1582-10-15T00:00:00Z. UUIDv1 places the fastest-changing time_low bits in the first 32 bits (bits 0-31), which scatters sequential inserts across B-tree index pages. UUIDv6 reorders those exact same 60 bits most-significant-first (time_high, time_mid, time_low) so lexicographical string order matches chronological creation order.

How can I tell if a UUID v1 node ID is a physical MAC address or randomly generated?

Check the least significant bit of octet 10 (the first byte of the 48-bit node field), which corresponds to the IEEE 802 unicast/multicast flag. Physical network card MAC addresses always have 0 in this bit (unicast), whereas RFC 9562 Section 6.10 specifies setting this bit to 1 (multicast) whenever a 48-bit pseudorandom node value is used instead of hardware.

What sub-millisecond timestamp precision can be decoded from UUID v7?

UUIDv7 guarantees 1-millisecond timestamp precision via its 48-bit unix_ts_ms field (bits 0-47). Although RFC 9562 Section 6.2 permits generators to place an optional sub-millisecond fraction or monotonic counter in rand_a (bits 52-63), the wire format includes no flag indicating whether rand_a holds random entropy, a counter, or fractional nanoseconds, so a general parser can only deterministically decode unix_ts_ms.

How does the parser handle Nil, Max, and UUID v8 identifiers?

All-zero (00000000-0000-0000-0000-000000000000) and all-one (ffffffff-ffff-ffff-ffff-ffffffffffff) inputs are identified as the RFC 9562 Nil and Max special UUIDs rather than invalid version 0 or version 15 values. For UUIDv8 (ver = 1000), the parser extracts custom_a (48 bits), custom_b (12 bits), and custom_c (62 bits) as raw hex and binary fields without guessing a timestamp, since v8 bit layouts are vendor-specific.