UUID Validator

Validate single or bulk UUID lists against RFC 9562 locally in-browser.

No uploadsNo sign-upInstant results
Strict RFC 9562 + Version FiltersBulk Line-by-Line DiagnosticsJSON & CSV Audit Report
Validate UUIDs
Offline engine ready100% private in-browser workspace • Zero cloud uploads
100% Private • Zero Server File Uploads

Why Use Utiliome's Free UUID Validator?

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

Complete RFC 9562 Version Coverage

Validates modern UUIDv6, UUIDv7, and UUIDv8 identifiers alongside classic v1 through v5 keys and the special all-zero Nil and all-one Max UUIDs that legacy RFC 4122 regexes reject.

Bulk Line-by-Line Classification & Filtering

Processes thousands of newline-delimited candidate strings in one pass, tagging each row with its detected version, variant prefix, and exact syntax error before exporting sanitized valid sets.

Strict Variant & Canonical Syntax Checks

Verifies exact 36-character 8-4-4-4-12 hexadecimal structure and distinguishes standard RFC 9562 variant bits (10xx) from legacy Microsoft COM/GUID (110x), NCS (0xxx), and non-hex tokens.

100% Local In-Browser Batch Processing

Runs syntax verification, lowercase normalization, and filtering entirely inside your browser tab without uploading database dumps, customer IDs, or log extracts to external servers.

Utiliome vs Traditional Cloud Alternatives

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

Feature Utiliome (Local Browser) Legacy Cloud Converters
Strict RFC 9562 vs Legacy GUID Modes Validates canonical 8-4-4-4-12 structure, variant (8,9,a,b), and version (1–8, Nil, Max) Loose hex regex that accepts invalid variant bits or non-RFC strings
Bulk List Auditing & Deduplication Validate thousands of IDs at once, isolating invalid rows, duplicates, and version counts Validates only one UUID string at a time
Format Normalization (URN, Braces, 32-Hex) Parses and normalizes {...}, urn:uuid:..., and 32-char compact hex into canonical lowercase Rejects valid UUIDs wrapped in braces or URN prefixes
100% In-Browser Dataset Privacy Audit production primary key exports locally with zero server uploads Uploads customer ID lists to remote validation endpoints
How it works

How to Use UUID Validator in 3 Easy Steps

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

1

Paste Candidate UUIDs or Upload a File

Enter a single UUID, paste a multi-line batch from application logs or SQL exports, or drop a local text or CSV file into the validator.

2

Review Per-Line Syntax, Version & Variant

Inspect the batch summary showing valid vs. invalid line counts, per-row version classification (v1 through v8, Nil, Max), and specific diagnostics for rejected lines.

3

Filter and Export Cleaned UUIDs

Filter the results to valid RFC 9562 identifiers or a specific UUID version, then copy or download the normalized lowercase list.

Bulk UUID Validation Walkthrough: Input Lists and Diagnostic Output

Quick Answer: When validating a multi-line list of candidate identifiers, each trimmed row is checked against the canonical 36-character 8-4-4-4-12 hexadecimal structure, matched against the Nil and Max special constants first, and then tested to confirm nibble 13 encodes version 1-8 and nibble 17 starts with the RFC 9562 10xx variant bits.

Data pipelines and API ingestion jobs frequently encounter mixed identifier formats—modern UUIDv7 keys, uppercase legacy GUIDs, sentinel constants, and non-UUID tokens like ULIDs. Below is a concrete seven-line batch demonstrating how RFC 9562 validation classifies each case.

Sample Multi-Line Candidate Input

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF
550e8400-e29b-91d4-a716-446655440000
550e8400-e29b-41d4-c716-446655440000
01ARZ3NDEKTSV4RRFFQ69G5FAV

Per-Row Classification Report

[
  {
    "line": 1,
    "input": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f",
    "valid": true,
    "classification": "UUIDv7",
    "variant": "RFC 9562 (10xx)",
    "normalized": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f"
  },
  {
    "line": 2,
    "input": "550e8400-e29b-41d4-a716-446655440000",
    "valid": true,
    "classification": "UUIDv4",
    "variant": "RFC 9562 (10xx)",
    "normalized": "550e8400-e29b-41d4-a716-446655440000"
  },
  {
    "line": 3,
    "input": "00000000-0000-0000-0000-000000000000",
    "valid": true,
    "classification": "Nil UUID (RFC 9562 Section 5.9)",
    "variant": "Nil (all zeros)",
    "normalized": "00000000-0000-0000-0000-000000000000"
  },
  {
    "line": 4,
    "input": "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF",
    "valid": true,
    "classification": "Max UUID (RFC 9562 Section 5.10)",
    "variant": "Max (all ones)",
    "normalized": "ffffffff-ffff-ffff-ffff-ffffffffffff"
  },
  {
    "line": 5,
    "input": "550e8400-e29b-91d4-a716-446655440000",
    "valid": false,
    "error": "Invalid version nibble '9' at position 15 (expected 1-8, or Nil/Max)"
  },
  {
    "line": 6,
    "input": "550e8400-e29b-41d4-c716-446655440000",
    "valid": false,
    "error": "Non-RFC-9562 variant nibble 'c' (110x Microsoft legacy GUID; expected 8, 9, a, or b)"
  },
  {
    "line": 7,
    "input": "01ARZ3NDEKTSV4RRFFQ69G5FAV",
    "valid": false,
    "error": "Invalid length (26 chars, Crockford Base32 ULID pattern; expected 36-char 8-4-4-4-12 hex)"
  }
]

Filtered Canonical Export

Exporting valid rows normalizes uppercase hexadecimal characters to canonical lowercase per RFC 9562 Section 4:

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
ffffffff-ffff-ffff-ffff-ffffffffffff

RFC 9562 Validation Rules, Regex Edge Cases, and Canonical Normalization

Quick Answer: A compliant RFC 9562 validator cannot rely on legacy RFC 4122 [1-5] regexes: it must accept versions 1 through 8 paired with variant [89ab] while explicitly whitelisting the all-zero Nil UUID and all-one Max UUID, and normalizing uppercase hex digits to canonical lowercase before string-indexed storage.

RFC 9562 (May 2024) expanded the UUID specification from five versions to eight and formalized two boundary constants, breaking older validation patterns still embedded in many validation libraries and API gateways.

Why Legacy RFC 4122 Regexes Fail on Modern Keys

Pre-2024 validators commonly enforce [1-5] on the 13th hexadecimal digit and omit sentinel values, rejecting valid UUIDv6, UUIDv7, UUIDv8, Nil, and Max keys. A complete, case-insensitive RFC 9562 regular expression matching canonical 8-4-4-4-12 syntax across v1-v8 plus Nil and Max is:

^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$

When validating untrusted input in backend runtimes such as Python, Ruby, or PCRE, anchor the end of the string with \z (or \Z in Python re.fullmatch) rather than $, because $ matches immediately before a trailing \n newline character and can allow newline-injected payloads through naive string checks.

Database `uuid` Types vs Strict Application Schemas

A frequent source of production ingestion failures is the mismatch between lenient database parsers and strict API schema validators:

  • Lenient 128-Bit Hex Parsers (e.g., PostgreSQL uuid): PostgreSQL accepts any 32 hexadecimal digits (with canonical hyphens, optional {...} braces, or no hyphens at all) regardless of version nibble (0-f) or variant prefix (0xxx, 10xx, 110x, 111x). Legacy Microsoft COM GUIDs (110x variant, hex c or d in digit 17) or arbitrary 128-bit MD5 digests stored in a uuid column pass SQL inserts without error.
  • Strict RFC 9562 Validators (OpenAPI, Zod, Rust uuid, Go google/uuid): Strict API schemas verify canonical 36-character hyphenation and often enforce variant 10xx and versions 1-8 (plus Nil/Max). Validating SQL exports in bulk before replaying them against strict REST or gRPC services catches non-RFC variant rows early.

Canonical Case Normalization

RFC 9562 Section 4 mandates that parsers accept uppercase A-F on input while producing lowercase a-f on output. Native 16-byte binary database types (UUID in PostgreSQL, BINARY(16) in MySQL) erase letter case automatically, but systems storing UUIDs in VARCHAR(36), Redis keys, DynamoDB partition keys, or JSON caches treat 550E8400-... and 550e8400-... as distinct strings unless normalized to lowercase during validation.

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

Quick Answer: Use the UUID Validator to verify syntax, check RFC 9562 compliance, classify versions across bulk lists, and export clean IDs. Use the UUID Parser & Decoder to extract embedded UTC timestamps and 128-bit fields from a specific UUID, or the UUID v4 Generator to mint new cryptographically random identifiers.

Choose the right Utiliome UUID utility based on whether you are auditing existing lists, inspecting internal bit fields, or generating fresh keys:

Capability UUID Validator (This Tool) UUID Parser & Decoder UUID v4 Generator
Primary Intent Validate single or multi-line UUID batches and filter out malformed entries Decode a UUID's 128-bit binary layout, node ID, and embedded UTC timestamp Generate bulk cryptographically random (CSPRNG) UUIDv4 identifiers
Bulk List Processing Yes — paste lists or upload files, view per-line diagnostics, and export valid sets No — designed for deep bit-field inspection of individual identifiers Outputs fresh batches of random v4 keys; does not validate external inputs
Version Coverage Classifies v1 through v8, Nil (0000...), and Max (ffff...) Decodes bit structures for v1 through v8, Nil, and Max Generates RFC 9562 UUIDv4 exclusively (use UUID v7, v6 & v1 Generator for time-ordered keys)
Timestamp Extraction Identifies whether a key is time-based (v1, v6, v7) without decoding dates Extracts exact ISO-8601 UTC dates, Unix ms, and 100-ns Gregorian ticks Not applicable (UUIDv4 contains 122 random bits and zero timestamp data)

Recommended Developer Workflows

  • Sanitizing CSV exports, logs, or migration payloads: Paste your list here to separate valid RFC 9562 identifiers from corrupted strings, ULIDs, or legacy non-RFC GUIDs and export a clean lowercase list.
  • Investigating when a time-based key was minted: Copy any valid v1, v6, or v7 identifier into the UUID Parser & Decoder to inspect its embedded UTC creation timestamp, clock sequence, and 128-bit binary fields.
  • Generating new identifiers: Use the UUID v4 Generator for unpredictable random tokens, or the UUID v7, v6 & v1 Generator for chronologically sortable database primary keys.
FAQ

UUID Validator FAQ and Technical Guide

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

Are Nil (all zeros) and Max (all Fs) valid UUIDs under RFC 9562?

Yes. RFC 9562 Section 5.9 defines 00000000-0000-0000-0000-000000000000 as the Nil UUID, and Section 5.10 defines ffffffff-ffff-ffff-ffff-ffffffffffff as the Max UUID for sentinel values and upper-bound range queries, even though their version and variant nibbles fall outside [1-8] and [89ab].

Why does a Microsoft GUID succeed in PostgreSQL but fail strict RFC 9562 validation?

Legacy Microsoft COM/DCOM GUIDs can carry the 110x backward-compatibility variant (hex c or d at the 17th hex digit) rather than the RFC 9562 10xx variant (8, 9, a, b). PostgreSQL's native uuid column type accepts any 128-bit hexadecimal value without checking version or variant bits, whereas strict RFC 9562 validators flag non-10xx variants.

Does uppercase hexadecimal make a UUID invalid?

No. RFC 9562 Section 4 states that parsers must accept uppercase A-F and lowercase a-f case-insensitively when reading UUIDs, while requiring generators and formatters to output canonical lowercase hexadecimal so case-sensitive string indexes and hash maps do not store duplicate keys.

Why do older UUID validation regexes reject UUID v7 and UUID v8?

Regex patterns written for RFC 4122 (published in 2005) hardcode [1-5] at the 13th hexadecimal digit because only versions 1 through 5 existed before May 2024, when RFC 9562 standardized reordered Gregorian v6, Unix Epoch time-ordered v7, custom v8, and the all-ones Max UUID.

Are ULIDs, braced GUIDs, or unhyphenated 32-character hex strings valid canonical UUIDs?

Not in canonical textual form. ULIDs encode 128 bits as 26 Crockford Base32 characters rather than hexadecimal, while {...} braces, urn:uuid: prefixes, and 32-character unhyphenated strings are alternative transport wrappers; RFC 9562 canonical UUID syntax strictly requires 36 characters formatted as 8-4-4-4-12 hexadecimal digits.