UUID Decoder & Validator | Analyze v1, v4, v7 & Time

Enter your UUID into the field above, and this tool (UUID Parser) will instantly perform an online check, determine its version, validity, and extract hidden information.

What is a UUID Decoder?

A UUID Decoder is a tool that analyzes a UUID (Universally Unique Identifier) and extracts all available information from it. A UUID is not just a random string of characters – depending on its version, it can contain a timestamp, system information, or a hash of deterministic data.

What Information Can You Get from a UUID?

Basic UUID Information

UUID Version:

  • Specifies the type and structure of the UUID (v1, v3, v4, v5, v6, v7)
  • Extracted from the 13th hexadecimal character

Variant:

  • RFC 4122 - Standard UUID variant
  • NCS - Network Computing System (deprecated)
  • Microsoft - Microsoft GUID variant
  • Reserved - Reserved for future use

UUID v1 - Timestamp + MAC Address

What you can get:

  • ✅ Precise creation time - date and time with 100-nanosecond precision
  • ✅ Clock Sequence - sequence number to prevent collisions
  • ✅ Node ID - originally a MAC address, often random values

Example:

UUID: 6ba7b810-9dad-11d1-80b4-00c04fd430c8

Version: v1 (Timestamp + MAC)
Variant: RFC 4122
Date and Time: 15.10.1997 04:25:33.000
Clock Sequence: 724
Node ID: 00:C0:4F:D4:30:C8

Usage:

  • Determining when a record was created
  • Audit and forensic analysis
  • Debugging time-dependent issues

UUID v3/v5 - Hash-based

What you can get:

  • ✅ Hash type - MD5 (v3) or SHA-1 (v5)
  • ❌ Cannot obtain - original namespace and name (one-way hash)

Example:

UUID: 886313e1-3b8a-5372-9b90-0c9aee199e5d

Version: v5 (SHA-1 hash)
Variant: RFC 4122
Type: Hash-based UUID (deterministic)
Note: The original namespace and name cannot be recovered from the UUID

Usage:

  • Verifying that a UUID is deterministic
  • Identifying the UUID type in a database
  • Checking the consistency of hash-based identifiers

UUID v4 - Random

What you can get:

  • ✅ Version - confirmation that it is random
  • ✅ Variant - RFC 4122 standard
  • ❌ No other data - purely random bits

Example:

UUID: f47ac10b-58cc-4372-a567-0e02b2c3d479

Version: v4 (Random)
Variant: RFC 4122
Type: Randomly generated UUID

Usage:

  • Verifying that a UUID is random (not deterministic)
  • Checking for correct UUID format
  • Validating UUIDs before storing them in a database

UUID v6 - Reordered Timestamp

What you can get:

  • ✅ Precise creation time - reordered for better DB performance
  • ✅ Clock Sequence - sequence number
  • ✅ Node ID - node identifier

Example:

UUID: 1ec9414c-232a-6b00-b3c8-9e6bdeced846

Version: v6 (Reordered Timestamp)
Variant: RFC 4122
Date and Time: 30.01.2026 14:23:45.123
Clock Sequence: 3272
Node ID: 9E:6B:DE:CE:D8:46

Usage:

  • Determining record creation time
  • Analyzing chronological ordering in DB
  • Debugging distributed systems

UUID v7 - Unix Timestamp

What you can get:

  • ✅ Unix timestamp - milliseconds since 1.1.1970
  • ✅ Date and Time - standard Unix timestamp format
  • ❌ Random part - cannot be decoded

Example:

UUID: 017f22e2-79b0-7cc3-98c4-dc0c0c07398f

Version: v7 (Unix timestamp)
Variant: RFC 4122
Date and Time: 30.01.2026 14:23:45.123

Usage:

  • Obtaining creation time for modern UUIDs
  • Analyzing time ordering
  • Data migration with timestamps

UUID Structure

A UUID has the format: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx

6ba7b810-9dad-11d1-80b4-00c04fd430c8
│      │ │  │ │  │ │  │ │           │
│      │ │  │ │  │ │  │ └───────────┴─ Node (48 bits)
│      │ │  │ │  │ └──┴─────────────── Clock Sequence (14 bits)
│      │ │  │ └──┴────────────────────── Variant (2-3 bits)
│      │ └──┴───────────────────────────── Version (4 bits) + Time High
│      └──────────────────────────────────── Time Mid (16 bits)
└─────────────────────────────────────────── Time Low (32 bits)

Extracting Versions and Variants

Version (M):

  • Position: 13th hexadecimal character
  • Values: 1-7 (different UUID versions)

Variant (N):

  • Position: 17th hexadecimal character
  • 0-7: NCS (Reserved)
  • 8-B: RFC 4122 (standard)
  • C-D: Microsoft
  • E-F: Future (Reserved)

Practical Examples

Debugging - Determining Record Creation Time

Scenario: A user reports that their data has disappeared. You need to find out when the record was created.

UUID: 6ba7b810-9dad-11d1-80b4-00c04fd430c8
Decoded: 15.10.1997 04:25:33.000

→ The record was created in 1997

Forensic Analysis - Verifying Time Sequence

Scenario: Checking whether events occurred in the correct order.

UUID 1: 1ec9414c-232a-6b00-b3c8-9e6bdeced846 → 30.01.2026 14:23:45
UUID 2: 1ec9414d-557b-6a00-8f32-1234567890ab → 30.01.2026 14:25:12

→ UUID 2 was created later (correct order)

Identifying UUID Type in a Database

Scenario: You have mixed UUIDs in your DB and need to know which are random and which have a timestamp.

f47ac10b-58cc-4372-a567-0e02b2c3d479 → v4 (random, no timestamp)
6ba7b810-9dad-11d1-80b4-00c04fd430c8 → v1 (has timestamp)
017f22e2-79b0-7cc3-98c4-dc0c0c07398f → v7 (has timestamp)

→ Only v1 and v7 UUIDs contain time information

Limitations and What Cannot Be Obtained

❌ UUID v3/v5 - Cannot Decode Hash

Impossible:

  • Recover the original namespace
  • Recover the original name/value
  • Determine what data was hashed

Reason: MD5 and SHA-1 are one-way hashing functions.

❌ UUID v4 - No Hidden Data

Impossible:

  • Obtain any metadata
  • Determine creation time
  • Identify the source

Reason: UUID v4 is purely random and contains no structured information.

⚠️ UUID v1/v6 - Node ID Can Be Random

Limitations:

  • In modern implementations, Node ID is often random (not a real MAC address)
  • Due to privacy concerns, MAC addresses are often replaced with random values
  • Cannot reliably identify a specific machine

UUID Validation

The decoder also functions as a UUID validator.

Checking UUID Validity

The decoder automatically validates:

  • ✅ Correct format (8-4-4-4-12 hexadecimal characters)
  • ✅ Valid hexadecimal characters (0-9, a-f)
  • ✅ Correct length (36 characters including hyphens, 32 without)

Recognizing Invalid UUIDs

Invalid examples:

❌ 6ba7b810-9dad-11d1-80b4          (too short)
❌ 6ba7b810-9dad-11d1-80b4-GHIJKLMN (invalid characters)
❌ 6ba7b81-09dad-11d1-80b4-00c04fd4 (wrong format)

For Developers

JavaScript Implementation

// Extracting UUID version
function getUUIDVersion(uuid) {
    const cleaned = uuid.replace(/-/g, '');
    return parseInt(cleaned[12], 16);
}

// Extracting timestamp from UUID v7
function extractV7Timestamp(uuid) {
    const cleaned = uuid.replace(/-/g, '');
    const timeHi = parseInt(cleaned.substring(0, 8), 16);
    const timeLow = parseInt(cleaned.substring(8, 12), 16);
    const unixMs = Number(BigInt("0x" + cleaned.substring(0, 12)) >> 16n);
    return new Date(unixMs);
}

// Example
const uuid = '017f22e2-79b0-7cc3-98c4-dc0c0c07398f';
console.log(getUUIDVersion(uuid)); // 7
console.log(extractV7Timestamp(uuid)); // Date object

UUID Validation using Regex

const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

function isValidUUID(uuid) {
    return uuidRegex.test(uuid);
}

Frequently Asked Questions (FAQ)

Can I get the creation time from a UUID v4? No, UUID v4 is purely random and contains no time information. For UUIDs with time, use v1, v6, or v7.
Why is the Node ID in UUID v1 random instead of a MAC address? Modern implementations use random Node IDs due to privacy protection. Revealing the actual MAC address could be a security risk.
Can I recover the original URL or name from a UUID v5? No, UUID v5 uses an SHA-1 hash, which is one-way. You cannot retrieve the original data from the hash.
How do I know if a UUID is random (v4)? The decoder will display the UUID version. If the version is 4, it is a randomly generated UUID with no other metadata.
Is the timestamp in UUID v1 accurate? Yes, UUID v1 has a theoretical precision of 100 nanoseconds (since October 15, 1582). In practice, it depends on the accuracy of the system clock.
Can I use the decoder to validate UUIDs? Yes, the decoder automatically validates the UUID format and displays an error if the UUID is invalid.

Security and Privacy

What does a UUID reveal?

UUID v1/v6:

  • ⚠️ Creation time - can reveal timing of operations
  • ⚠️ Potentially MAC address - risk of device identification (random in modern implementations)

UUID v4:

  • ✅ Secure - contains no metadata

UUID v7:

  • ⚠️ Unix timestamp - reveals creation time

Recommendations

  • ✅ Use UUID v4 for maximum privacy
  • ⚠️ Be cautious with UUID v1/v6/v7 in public APIs (they reveal time information)
  • ✅ UUID v5 is deterministic but does not reveal original data
  • ⚠️ MD5 Hash is not completely secure

Interesting Facts

  • Earliest possible UUID v1: October 15, 1582 00:00:00 (beginning of the Gregorian calendar)
  • Latest UUID v7: 10889-08-02 05:31:50.655 (Unix timestamp limit in ms)
  • UUID v1 precision: 100 nanoseconds (theoretically 10 million UUIDs per second)
  • Nil UUID: 00000000-0000-0000-0000-000000000000 (special “empty” UUID)
  • Max UUID: ffffffff-ffff-ffff-ffff-ffffffffffff (maximum value)

Usage in Different Systems

PostgreSQL

-- Extract UUID version
SELECT substring(id::text, 15, 1) as version
FROM users;

-- Filtering by version
SELECT *
FROM users
WHERE substring(id::text, 15, 1) = '4';

MySQL

-- Check UUID format
SELECT id
FROM users
WHERE id REGEXP '^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$';