UUID Validator
Validate UUIDs instantly, identify their versions and variants, detect invalid formats, and normalize identifiers. Check single UUIDs or bulk lists, then copy or download your validation results.
UUID Input
Validation Results
All Developer Tools
Browse free online tools for JSON, HTML, CSS, XML, JavaScript, data conversion, and everyday development tasks.
Try a different search term or select another category.
What Is a UUID Validator?
A UUID validator checks whether a Universally Unique Identifier follows the expected UUID format. It can help identify incorrect lengths, invalid hexadecimal characters, misplaced hyphens, and version or variant bits that do not match the rules being checked.
A UUID is a 128-bit identifier commonly written as 32 hexadecimal characters in five groups separated by hyphens. The canonical format follows an 8-4-4-4-12 pattern. UUIDs are widely used for database records, API resources, application events, sessions, and distributed systems.
Paste an identifier into the validator to inspect its structure. If your tool supports bulk validation, you can also check a list of UUIDs and review the results for individual entries.
Important: A UUID validator checks formatting and the rules implemented by the tool. A valid result does not prove that the identifier is unique, was generated correctly, or exists in a particular database.
How to Validate a UUID
Use these steps to check a UUID or GUID and understand whether its structure matches the expected format.
Paste the identifier you want to check into the UUID validator's input field. Use the format accepted by the tool.
Run the validation to check the UUID's length, hexadecimal characters, hyphen positions, and applicable version and variant rules.
Check whether the identifier passes the implemented validation rules. Review any reported formatting problems or version and variant details.
If bulk validation is supported, enter multiple identifiers, commonly one per line, to review several values in one session.
Copy the results or use the identifiers in your application after confirming that they meet your system's requirements.
For strict validation, use the UUID representation expected by your application. Some validators accept only canonical UUID strings, while others also recognize compact, braced, or URN representations.
UUID Validator Features
A UUID validator can help developers inspect identifier structure, detect formatting mistakes, and review UUIDs before using them in APIs, database records, logs, and data migrations.
UUID Structure Validation
Check the expected UUID length, hexadecimal characters, hyphen placement, and five-group canonical format.
UUID Version Detection
Identify supported UUID versions, including v1, v3, v4, v5, v6, v7, and v8, by inspecting the version field.
UUID Variant Inspection
Inspect the variant bits to determine whether the identifier uses the expected standard UUID variant.
Bulk UUID Validation
Check multiple UUIDs in one session when reviewing application logs, database exports, or test datasets.
Multiple Input Formats
Support canonical UUID strings and, where implemented, compact strings, braced GUIDs, or URN-style representations.
Nil and Max UUID Recognition
Recognize the all-zero Nil UUID and all-one Max UUID as special values that should be distinguished from ordinary versioned UUIDs.
Canonical Formatting
Display an identifier in a consistent representation when normalization or formatting options are supported.
UUID Structure Analysis
Review the available version, variant, and structural information to help troubleshoot malformed identifiers.
The exact features depend on the validator's implementation. Alternate input formats, downloadable reports, canonical formatting, and browser-only processing should be advertised only when the tool actually supports them.
What Is a Valid UUID Format?
A canonical UUID contains 32 hexadecimal digits grouped into five sections separated by four hyphens. Its standard text representation contains 36 characters in total.
In this pattern, M represents the version field and N represents the beginning of the variant field. For commonly supported, standard-variant versioned UUIDs, these positions are checked against the applicable version and variant rules.
UUID validation rules
- Correct length: A canonical UUID contains 36 characters, including four hyphens.
- Hexadecimal characters: UUID digits use
0-9and lettersa-forA-F. - Hyphen placement: The five groups follow the
8-4-4-4-12pattern. - Version field: For the supported standard versioned UUIDs, the version field identifies the version, such as v1, v3, v4, v5, v6, v7, or v8.
- Variant field: The standard UUID variant is identified by its variant bits. In canonical hexadecimal form, the usual first character of the fourth group is
8,9,a, orb.
Note: The Nil UUID and Max UUID are special values and do not follow the ordinary versioned-UUID pattern. A validator should handle them separately when its rules are intended to recognize these special identifiers.
UUID Versions Explained
UUID versions use different methods to construct identifiers. Checking the version field can help you understand what type of UUID you are examining.
| UUID Version | Type | Common Purpose |
|---|---|---|
| UUID v1 | Time-based | Uses a timestamp and node-related information to construct the identifier. |
| UUID v3 | Name-based, MD5 | Generates a deterministic identifier from a name and namespace. |
| UUID v4 | Random or pseudorandom | Commonly used for application IDs, database keys, and resource identifiers. |
| UUID v5 | Name-based, SHA-1 | Generates a deterministic identifier from a name and namespace. |
| UUID v6 | Reordered time-based | Reorders time-related fields to support chronological sorting. |
| UUID v7 | Time-ordered | Combines a Unix timestamp in milliseconds with additional data. |
| UUID v8 | Custom or application-specific | Supports application-specific layouts that conform to the version and variant requirements. |
Version detection identifies the version field; it does not prove that the UUID was generated using the correct algorithm. For example, a string containing a v4 version field is not proof that its remaining bits were produced by a proper random UUID generator.
UUID Validation Example
The following example shows a correctly structured UUID v4 and the type of information a validator can report when it supports version and variant inspection.
Input UUID
Example Result
UUID: 550e8400-e29b-41d4-a716-446655440000
Version: v4
Variant: Standard RFC UUID variant
Canonical format: 36-character UUID with the expected hyphen placement.
The third group starts with 4, identifying version 4. The fourth group starts with a, which matches the standard UUID variant. These fields are consistent with a conventionally formatted UUID v4.
Keep in mind: A valid format does not confirm that a UUID exists in a database, has never been used before, or was generated by a trusted process.
Supported UUID Input Formats
UUIDs can appear in different textual formats. These examples show common representations that a validator may accept when it supports input normalization.
550e8400-e29b-41d4-a716-446655440000
550E8400-E29B-41D4-A716-446655440000
{550e8400-e29b-41d4-a716-446655440000}
urn:uuid:550e8400-e29b-41d4-a716-446655440000
550e8400e29b41d4a716446655440000
550e8400-e29b-41d4-a716-446655440000
Uppercase and lowercase hexadecimal letters represent the same UUID value. Braces, URN prefixes, and compact representations are different input formats, however, and are not necessarily accepted by a strict canonical-format validator.
Format compatibility: Confirm which representations your validator accepts. Do not treat every alternative representation as supported unless the tool explicitly normalizes or validates it.
Who Uses a UUID Validator?
UUID validation is useful anywhere identifiers move between applications, APIs, databases, and data-processing systems.
Backend Developers
Validate UUIDs in API path parameters, request bodies, response payloads, and application configurations before processing them.
Database Teams
Inspect UUID primary keys and identifier fields before inserts, imports, migrations, or related-record operations.
QA and API Testers
Check identifier formats in test data, API responses, and integration workflows to catch malformed values.
Data Engineers
Review UUID fields in CSV exports, logs, migration files, and data-processing pipelines.
Support Teams
Inspect request IDs, correlation IDs, session identifiers, and resource IDs while investigating application issues.
Software Teams
Catch malformed identifiers before passing them to dependent services, databases, or application components.
Why Validate UUIDs?
Malformed identifiers can cause failed API requests, rejected database operations, import errors, and problems connecting related records. Validating UUID structure early helps identify formatting problems before the data reaches other parts of an application.
Common Reasons to Validate UUIDs
- Before database insertion: Check that an identifier follows the format expected by the database field or application.
- During API testing: Validate UUID parameters and payload fields before sending requests to a service.
- When reviewing logs: Inspect correlation IDs, request IDs, and resource identifiers during troubleshooting.
- During data migrations: Find malformed UUID values in imported datasets or exported database records.
- When checking UUID versions: Inspect supported version and variant fields where the application requires a particular UUID format.
- When identifying special values: Distinguish Nil and Max UUIDs from ordinary versioned identifiers.
Validation is only one part of data quality. Your application may also need database constraints, existence checks, authorization, and uniqueness checks depending on how identifiers are used.
Nil UUID and Max UUID
The Nil UUID and Max UUID are special 128-bit values. They should be distinguished from ordinary versioned UUIDs when interpreting validation results.
Nil UUID
The Nil UUID contains all zero bits. An application may use it as a special placeholder or to represent the absence of an assigned UUID.
Max UUID
The Max UUID contains all one bits. It is a special value rather than an ordinary versioned UUID.
Validation detail: A strict checker for ordinary versioned UUIDs may reject these special values under its regular version and variant rules. A validator that explicitly recognizes Nil and Max UUIDs can report them separately.
Is My Data Private?
UUIDs may appear in internal database records, application logs, API payloads, and other operational data. Before submitting an identifier, check how the validator processes your input.
Check the Tool's Processing Method
If the validator performs all checks locally in your browser, your UUIDs do not need to be uploaded to a validation server. This can be useful when reviewing internal identifiers or production data.
Privacy depends on the actual implementation. Do not claim that input is never uploaded unless the tool's code and behavior confirm browser-only processing.
Frequently Asked Questions
What is a UUID?
A UUID is a 128-bit identifier commonly written as 32 hexadecimal characters in five hyphen-separated groups. Applications use UUIDs to identify records, resources, sessions, and messages.
What is the difference between a UUID and a GUID?
UUID and GUID refer to essentially the same type of identifier. GUID is the term commonly used in Microsoft environments, while UUID is the broader standards-based term.
Is this UUID validator free?
Usage limits and available features depend on the tool. A free online UUID validator can let you check identifier formats without installing separate validation software.
Can a UUID validator detect the version?
Yes, if version detection is implemented. A validator can inspect the version field and identify supported versions such as v1, v3, v4, v5, v6, v7, and v8.
Can I validate multiple UUIDs at once?
Bulk validation allows you to check multiple identifiers in one session. If the tool supports it, you can enter one UUID per line and review each result separately.
Does uppercase or lowercase matter in a UUID?
No. Uppercase and lowercase hexadecimal letters represent the same UUID value. Canonical UUID strings are commonly displayed in lowercase.
What makes a UUID invalid?
Common problems include incorrect length, misplaced hyphens, non-hexadecimal characters, an unsupported version field, or variant bits that do not match the expected variant.
Is a valid UUID guaranteed to be unique?
No. Validation checks structure and any additional rules implemented by the tool. It does not prove uniqueness, and UUID collision risk depends on the version and generation method.
Can I use a UUID as a database primary key?
Yes. UUIDs are commonly used as database primary keys and distributed identifiers. Your database and application should still enforce appropriate data types, relationships, and constraints.
Does a UUID validator check whether an ID exists?
No. Format validation cannot confirm that a UUID belongs to a record in your database or that a resource exists in an application. That requires checking the relevant data source.
Can a validator accept UUIDs without hyphens?
Some validators support compact UUIDs containing 32 hexadecimal characters without hyphens. Others accept only the canonical hyphenated format, so check the supported input formats.
Are Nil UUIDs and Max UUIDs valid?
They are defined special UUID values. A validator may recognize them separately from ordinary versioned UUIDs rather than applying the same version checks used for conventional UUIDs.
Does this UUID validator upload my data?
That depends on the tool's implementation. If processing occurs entirely in the browser, input does not need to be uploaded to a server. Verify the actual processing behavior before submitting confidential identifiers.
Related Developer Tools
Explore other developer utilities for generating identifiers and working with structured data.
Use these tools as part of your development workflow when creating identifiers, reviewing data, or troubleshooting formatting problems.