Home›Validators›Data›UUID Validator

UUID Validator

Data

Validate any UUID (v1–v5) instantly — checks the 8-4-4-4-12 hexadecimal format and identifies the version. Free, client-side, no sign-up required.

Reviewed by the thecalcu.com team · Last updated June 29, 2026

What is a UUID?

A UUID Validator checks whether a string is a correctly formatted UUID (Universally Unique Identifier) according to the RFC 4122 standard. A UUID is a 128-bit identifier expressed as 32 hexadecimal digits arranged in the pattern 8-4-4-4-12, for example, 550e8400-e29b-41d4-a716-446655440000. UUIDs appear throughout software development as database primary keys, API request identifiers, session tokens, file names, and anywhere a unique identifier needs to be generated without central coordination.

The RFC 4122 standard defines five UUID versions. Version 1 is time-based and encodes the current timestamp and MAC address. Version 2 is used in DCE security systems. Versions 3 and 5 generate deterministic UUIDs from a namespace and name using MD5 or SHA-1 hashing respectively. Version 4, by far the most common, uses random or pseudo-random bits, making collisions statistically negligible. Each version encodes its number at a specific position in the UUID string (the 13th hex digit), which is how this validator detects and reports the version.

Beyond format, the RFC 4122 standard also specifies a variant byte at position 19 in the UUID string. RFC 4122-compliant UUIDs use a variant byte of 8, 9, a, or b. Older NCS compatibility UUIDs and Microsoft COM/GUID UUIDs use different variant bytes. This validator checks all three layers: correct hexadecimal characters, correct 8-4-4-4-12 structure, valid version (1–5), and RFC 4122 variant byte.

If you are working with API responses and want to verify that IDs are well-formed, you can also use the URL Validator and Email Validator to check other common identifier formats.

Why Use a UUID Validator?

Format errors in UUIDs are easy to introduce and hard to spot by eye. A UUID with one wrong character looks almost identical to a valid one. Common real-world problems include:

  • Copy-paste truncation, UUIDs copied from logs or terminals sometimes lose their trailing characters if the line wraps
  • Case normalisation bugs, some systems convert to uppercase or lowercase inconsistently, introducing characters outside 0-9a-f
  • Version or variant mismatches, manually constructed or test UUIDs sometimes use a version digit of 0 or 6, which is not a valid RFC 4122 version
  • Whitespace contamination, a leading or trailing space makes a valid UUID fail silently in strict parsers

This validator catches all of these instantly. It is particularly useful when debugging API integrations, checking database migration scripts, or verifying that a UUID field in a form submission is structurally correct before it reaches your backend.

Who Should Use This Validator?

Backend and full-stack developers use it when debugging API calls where a UUID primary key or correlation ID behaves unexpectedly, paste it in, confirm the format, move on.

QA engineers and testers use it to verify that auto-generated IDs in test fixtures follow the correct format before those fixtures are committed.

Database administrators use it when migrating data between systems, especially when UUIDs are stored as VARCHAR rather than a native UUID column type and format constraints are not enforced by the schema.

Front-end developers use it when building forms that accept user-supplied UUIDs (document IDs, invitation codes) and need to validate format before a network request is made. You can use the Regex Tester if you need to test a custom UUID-adjacent pattern.

Technical support teams use it when users report errors referencing a UUID, a quick format check confirms whether the ID they pasted is structurally valid, ruling out a copy-paste issue before escalating.

What Insights Does the UUID Validator Give You?

A valid result tells you three things: the UUID is correctly structured (8-4-4-4-12 hex groups, 36 characters total), it uses a recognised RFC 4122 version (1–5), and its variant byte conforms to RFC 4122 (8, 9, a, or b). The version is identified by name, for example, "v4, randomly generated", which is useful when auditing systems that are expected to use a specific version.

An invalid result includes a specific reason: wrong length, non-hexadecimal characters, unrecognised version digit, or invalid variant byte. This is more useful than a plain "Invalid" because it tells you exactly where the string deviates from the standard.

What this validator does not tell you: whether the UUID is unique, whether it was generated correctly by its source system, or whether it exists in any database. UUID uniqueness is a mathematical property of the generation algorithm, not something verifiable from the string itself.

How to use this UUID calculator

  1. Copy the UUID string you want to check, from a database record, API response, log file, or form input.
  2. Paste it into the UUID input field on this page.
  3. The validator runs instantly, no button press needed.
  4. Check the Valid / Invalid badge below the input.
  5. If valid, read the details breakdown: format confirmation, version name, and variant.
  6. If invalid, read the error message, it specifies the exact problem (wrong length, bad characters, unrecognised version, or invalid variant byte).
  7. Fix the UUID in your source and re-paste to re-validate.

Formula & Methodology

A UUID is validated against this regular expression (case-insensitive):

/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i

Breaking this down:
- [0-9a-f]{8}, 8 hexadecimal characters (first group)
- -[0-9a-f]{4}, hyphen + 4 hex chars (second group)
- -[1-5][0-9a-f]{3}, hyphen + version digit (1–5) + 3 hex chars (third group)
- -[89ab][0-9a-f]{3}, hyphen + RFC 4122 variant byte (8/9/a/b) + 3 hex chars (fourth group)
- -[0-9a-f]{12}, hyphen + 12 hex chars (fifth group)

Valid example: 550e8400-e29b-41d4-a716-446655440000, UUID v1, 36 characters, RFC 4122 variant.

Invalid example: 550e8400-e29b-61d4-a716-446655440000, fails because position 14 is 6, which is not a valid UUID version (valid range: 1–5).

Version is read from character at index 14 (0-based) of the UUID string. Version labels: v1 = time-based, v2 = DCE security, v3 = namespace/MD5, v4 = random, v5 = namespace/SHA-1.

Frequently Asked Questions

A UUID (Universally Unique Identifier), also called a GUID (Globally Unique Identifier), is a 128-bit identifier formatted as 32 hexadecimal digits separated into five groups: 8-4-4-4-12. For example: 550e8400-e29b-41d4-a716-446655440000. UUIDs are designed to be unique across time and space without requiring a central registry.
This validator supports all five RFC 4122 UUID versions: v1 (time-based), v2 (DCE security), v3 (namespace with MD5 hashing), v4 (randomly generated), and v5 (namespace with SHA-1 hashing). The version number is encoded at position 13 of the UUID string (the first character of the third group).
The numbers refer to the count of hexadecimal characters in each hyphen-separated group. A complete UUID is always 36 characters long: 8 hex chars, a hyphen, 4 hex chars, a hyphen, 4 hex chars, a hyphen, 4 hex chars, a hyphen, and 12 hex chars. The total hex digit count is 32 (128 bits).
UUID and GUID refer to the same concept. UUID is the term used in the RFC 4122 standard, while GUID (Globally Unique Identifier) is the term used by Microsoft in its COM/OLE systems. Structurally they are identical, both are 128-bit identifiers in the 8-4-4-4-12 hexadecimal format. This validator accepts both uppercase and lowercase hex digits.
Paste your UUID string into the input field. The validator checks it live, no button press needed. You will see a Valid or Invalid badge, and if valid, the UUID version is identified. If invalid, a specific reason is shown (wrong length, invalid characters, unrecognised version, or wrong variant byte).
Check the error message shown below the badge, it specifies exactly what is wrong. Common issues are: missing or extra hyphens, non-hexadecimal characters (like g, h, or spaces), a version digit outside 1–5, or a variant byte that is not 8, 9, a, or b. Copy the UUID directly from its source rather than retyping it to avoid transcription errors.
No. This tool performs a structural format check only, it confirms that the UUID follows the correct 8-4-4-4-12 hexadecimal format and is a valid RFC 4122 identifier. It does not and cannot verify that the UUID is unique, that it was generated correctly, or that it exists in any system. UUID uniqueness is a statistical property of the generation process, not something that can be verified by inspecting the string.
No. All validation happens entirely in your browser, nothing is transmitted to any server, stored, or logged. UUIDs often appear in database primary keys, API tokens, and session identifiers, so client-side processing is important for privacy.
The variant byte is the first character of the fourth group (position 19 in the UUID string). RFC 4122 UUIDs, the most common type, use a variant byte of 8, 9, a, or b. This is part of the UUID specification and distinguishes RFC 4122 UUIDs from older NCS or Microsoft COM UUIDs. If the variant byte is anything else, the UUID does not conform to RFC 4122.
Yes. The validator accepts both uppercase (A–F) and lowercase (a–f) hexadecimal characters. The RFC 4122 standard recommends lowercase for canonical representation, but uppercase is equally valid and widely used, particularly in Windows/GUID contexts.
UUID v4 is randomly generated, 122 of its 128 bits are cryptographically random, making collisions astronomically unlikely. It is by far the most common UUID version in modern software because it requires no coordination, no timestamp, and no namespace seed. Most UUID generation libraries (including crypto.randomUUID() in browsers) produce v4 UUIDs by default.
Both v3 and v5 are namespace-based UUIDs, they generate a deterministic UUID from a namespace UUID plus a name string. The difference is the hashing algorithm: v3 uses MD5 and v5 uses SHA-1. The same namespace and name always produce the same UUID, which makes them useful for content-addressable identifiers. V5 is preferred over v3 because SHA-1 is more collision-resistant than MD5.
Also known as
check uuidvalidate guidguid validatoruuid format checkeruuid v4 validatoris this uuid valid