Free UUID Validator · Instant · Browser-Only

UUID Validator

Validate any UUID or GUID instantly — detects version, variant, format errors, and shows decoded fields. Works offline. Nothing is sent to any server.

Paste or type a UUID above to validate it instantly

★ 100% Free ✓ All 8 Versions 🔒 Browser-Only · Zero Server Calls ★ RFC 9562 Compliant

What This Tool Does

How the UUID Validator Works

This tool performs instant client-side UUID validation entirely in your browser using JavaScript. When you paste a UUID, it checks three things in sequence:

Check	What it verifies	Common errors caught
Format	The string matches the 8-4-4-4-12 hexadecimal pattern (36 characters with hyphens)	Wrong length, non-hex characters, missing hyphens, extra characters
Version bit	Character at position 13 (the version digit) is 1–8	Version 0 or 9+ (invalid), corrupt UUID, truncated value
Variant bit	Character at position 17 is 8, 9, a, or b (RFC 4122/9562 variant)	Older pre-RFC formats, non-standard UUID types, byte-order variants

It also accepts UUIDs with curly braces ({…} as used in C# and COM), and UUIDs without hyphens (32 hex characters), normalising them to canonical form before validation.

🔒

Your UUIDs never leave your browser

Every UUID you paste is validated locally using your browser’s JavaScript engine. Nothing is transmitted, logged, or stored. Open your browser’s Network tab and confirm — you will see zero outbound requests when you validate.

Format Reference

What Makes a UUID Valid?

A valid RFC-compliant UUID must satisfy all of the following:

Property	Required Value	Example
Total length	36 characters (with hyphens) or 32 (without)	xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Character set	Hexadecimal only: 0-9 and a-f (case-insensitive)	a-f, 0-9 — no g, h, z, etc.
Hyphen positions	After characters 8, 12, 16, and 20	Groups of 8-4-4-4-12 hex digits
Version digit	Character 13: must be 1, 2, 3, 4, 5, 6, 7, or 8	550e8400-e29b-41d4-…
Variant bits	Character 17: must be 8, 9, a, or b	…-41d4-a716-…
Nil UUID	All 32 digits are zero — valid sentinel value	00000000-0000-0000-0000-000000000000
Max UUID	All 32 digits are f — valid sentinel value (RFC 9562)	ffffffff-ffff-ffff-ffff-ffffffffffff

Version Detection

Detected UUID Versions

This validator automatically detects which UUID version a string represents and provides a plain-English explanation of how it was generated:

Version	Name	How to identify	Common use
v1	Time-based	Char 13 = 1. Contains a 60-bit Gregorian timestamp.	Legacy distributed systems. Avoid in user-facing apps (leaks MAC address).
v2	DCE Security	Char 13 = 2. Similar to v1 with DCE principal embedded.	Rare. DCE/POSIX systems only.
v3	Name-based (MD5)	Char 13 = 3. Deterministic from namespace + name.	Deduplication where v5 is unavailable. Prefer v5.
v4	Random	Char 13 = 4. 122 random bits.	General-purpose. Default for most applications.
v5	Name-based (SHA-1)	Char 13 = 5. Deterministic from namespace + name.	Reproducible IDs from known inputs. Preferred over v3.
v6	Time-ordered	Char 13 = 6. Reordered v1 timestamp bits.	v1 migration path. Better B-tree index locality.
v7	Unix Timestamp	Char 13 = 7. 48-bit Unix ms timestamp prefix.	Database primary keys in 2026. Recommended over v4 for PKs.
v8	Custom	Char 13 = 8. All other bits are implementation-defined.	Custom structured IDs with application-specific layouts.

Code Examples

How to Validate a UUID in Code

Need to validate UUIDs programmatically? Here are production-ready patterns for the most common languages:

JavaScript / TypeScript

JavaScript

// Validate any RFC 4122 / RFC 9562 UUID (versions 1-8) const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i; function isValidUUID(uuid) { if (uuid === ‘00000000-0000-0000-0000-000000000000’) return true; // Nil if (uuid === ‘ffffffff-ffff-ffff-ffff-ffffffffffff’) return true; // Max return UUID_REGEX.test(uuid); } // Examples isValidUUID(‘550e8400-e29b-41d4-a716-446655440000’); // true (v4) isValidUUID(‘not-a-uuid’); // false

Python

import uuid def is_valid_uuid(value: str) -> bool: try: uuid.UUID(str(value)) return True except ValueError: return False # Examples is_valid_uuid(‘550e8400-e29b-41d4-a716-446655440000’) # True is_valid_uuid(‘not-a-uuid’) # False # Get version info u = uuid.UUID(‘550e8400-e29b-41d4-a716-446655440000’) print(u.version) # 4 print(u.variant) # UUID RFC 4122

PHP

SQL (PostgreSQL)

PostgreSQL

— PostgreSQL has a native uuid type that validates automatically — Casting fails for invalid UUIDs SELECT ‘550e8400-e29b-41d4-a716-446655440000’::uuid; — OK SELECT ‘not-a-uuid’::uuid; — ERROR: invalid uuid — Safe validation function CREATE OR REPLACE FUNCTION is_valid_uuid(val TEXT) RETURNS BOOLEAN AS $$ BEGIN PERFORM val::uuid; RETURN TRUE; EXCEPTION WHEN invalid_text_representation THEN RETURN FALSE; END; $$ LANGUAGE plpgsql;

Common Errors

Common UUID Validation Errors & Fixes

Error	Example	Fix
Wrong length	550e8400-e29b-41d4-a716 (too short)	A UUID must have 36 characters including hyphens. Check for truncation during serialization or database storage.
Invalid version digit	550e8400-e29b-91d4-a716-…	Position 13 must be 1-8. Version 9+ does not exist in RFC 9562. Check your UUID generation library.
Invalid variant bit	…-41d4-c716-…	Position 17 must be 8, 9, a, or b. ‘c’ indicates a non-RFC format (e.g. a Microsoft GUID in binary with reversed byte order).
Non-hex characters	550e8400-e29g-41d4-…	‘g’ is not a hex character. Only 0-9 and a-f (case-insensitive) are valid.
Missing hyphens	550e8400e29b41d4a716446655440000	32-digit no-hyphen form is valid if the format is exactly 32 hex chars. This validator accepts it automatically.
Null/empty	NULL, undefined, “”	Use the Nil UUID (00000000-0000-0000-0000-000000000000) as a sentinel rather than empty strings or null where UUID type is required.

FAQ

Frequently Asked Questions

Paste the UUID into the validator above. It checks three things: (1) the string matches the 8-4-4-4-12 hexadecimal format, (2) the version digit (character 13) is between 1 and 8, and (3) the variant bit (character 17) is 8, 9, a, or b. All three must pass for a UUID to be considered RFC-compliant.

The standard regex for validating RFC 4122 and RFC 9562 UUIDs (versions 1-8) is: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i — The [1-8] anchors the version digit to currently-defined versions. The [89ab] anchors the variant to the RFC 4122/9562 range. Always apply the regex case-insensitively since both uppercase and lowercase hex are valid.

Yes. A UUID without hyphens is a 32-character hexadecimal string. This is called the “N” format. It is valid and commonly used in database storage (BINARY(16) or CHAR(32)) and compact URL tokens. This validator accepts both the hyphenated 36-character form and the compact 32-character form, automatically detecting which one you pasted.

Yes. The format {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} with curly braces is commonly used in C#, COM, and Windows Registry contexts. It is the same UUID in the “B” format (as defined by ToString(“B”) in C#). This validator strips the braces before validation, so you can paste C# GUIDs directly.

The variant bits (character 17 in the hyphenated string) identify the UUID standard the identifier follows. Values 8, 9, a, or b indicate RFC 4122/9562 compliance, which is the current standard used by virtually all modern systems. Other values indicate older pre-RFC formats (variant 0), Microsoft COM GUIDs in binary little-endian form (variant c-d), or reserved future formats (variant e-f). If your UUID has a variant bit outside the 8-9-a-b range, it may still work in some contexts but is not strictly RFC-compliant.

In modern browsers and Node.js 19+, you can use crypto.randomUUID() to generate and implicitly validate. To explicitly validate, use the regex: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i — Apply it with .test(uuid) and handle the Nil UUID (all zeros) as a special case. For TypeScript projects, the zod library has a built-in z.string().uuid() validator that uses this pattern.

UUID validation checks that a string conforms to the correct format and structure defined by RFC 4122 and RFC 9562. UUID verification is a business-logic concept that checks whether a specific UUID exists in a database or system. This tool performs format validation only. Whether a validated UUID belongs to an actual entity in your system is a separate database lookup your application must perform.

Need to Generate a UUID?

Our UUID generator supports all 8 versions — v4, v7, v1, v5, v6, v8, Nil, and Max. Free, RFC 9562 compliant, bulk export.

Open UUID Generator