🔎

UUID Validator

Validate UUID format and detect the version. Paste one or many UUIDs (one per line) for bulk validation.

About UUID Validator — UUID Validator Online

This UUID validator online checks whether any string is a correctly formatted UUID and identifies which version (v1 through v8) it belongs to. It also detects the RFC 4122 variant field, flags the special nil UUID (all zeros), and normalizes both uppercase and lowercase inputs — with or without hyphens. Developers, QA engineers, database administrators, and API integrators use UUID validators to catch malformed identifiers before they cause silent failures in production systems.

Malformed UUIDs are a surprisingly common source of bugs. A UUID copied from a Slack message might have an extra space or a missing group. A database export might produce compact 32-character strings without hyphens. An API might return a UUID in uppercase when your code expects lowercase. Validating UUIDs before inserting them into a database or sending them to an API prevents constraint violations, 404 errors, and hard-to-trace runtime exceptions. This tool lets you validate one UUID or an entire list at once, with a clear pass/fail result and detailed version and variant information for every valid entry.

How to Use the UUID Validator

  1. Paste a UUID (or multiple UUIDs, one per line) into the text area — you can paste up to hundreds of lines for bulk validation.
  2. Click Validate to run all checks. Each UUID gets a green checkmark (valid) or a red cross (invalid) instantly.
  3. For valid UUIDs, the tool displays the detected version (v1, v4, v5, v7, etc.) and the variant (RFC 4122, NCS, Microsoft COM, or Reserved).
  4. The summary bar at the top shows total count, valid count, and invalid count so you can see the overall health of your list at a glance.
  5. Click Clear to reset the input and results when you're done.

What the Validator Checks

The validator performs several checks in sequence to give you the most detailed result possible for each UUID.

  • Format compliance: The UUID must match the pattern xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx — exactly 32 hexadecimal digits in five groups separated by four hyphens. Compact 32-character strings without hyphens are automatically expanded before checking, so both forms are accepted.
  • Version detection: Bit 48–51 (the 13th character) encodes the UUID version. The validator reads this nibble and reports v1 through v8. Version 0 or an out-of-range value is flagged as non-standard but still structurally valid.
  • Variant detection: Bits 64–65 define the UUID layout. RFC 4122 (the most common standard) requires the variant bits to be "10xx", encoded as hex 8, 9, a, or b in position 17. The validator reports RFC 4122, NCS backward-compatible, Microsoft COM, or Reserved as appropriate.

Tips for Getting the Best Results

How to get the most accurate results:

  • Paste one UUID per line for bulk validation: The tool splits input by newlines, so you can paste an entire column from a spreadsheet, a database export, or an API log file. Each line is checked independently, and the summary bar shows you exactly how many passed and failed.
  • Don't worry about case or hyphens: The validator normalizes both uppercase and lowercase hex and accepts the compact 32-character format in addition to the standard hyphenated format. Paste whatever format you have and the tool will handle it correctly.
  • Check the variant as well as the version: A UUID can have the right format and a valid version digit but still be non-RFC-4122 if the variant bits are wrong. If you're integrating with a system that strictly enforces RFC 4122 compliance, make sure both the version and variant tags show the expected values.
  • Use bulk validation for database auditing: Export a column of UUIDs from your database into a text file, paste the contents here, and look for any invalid entries. Invalid UUIDs in a database column often indicate data corruption, a bug in a data import pipeline, or a missed validation step in an API endpoint.
  • Validate before sending to an API: If your application passes UUID values as path parameters or query strings to a REST API, a malformed UUID will likely cause a 400 Bad Request or 404 Not Found error. Validate the UUID before making the request to produce a cleaner error message for your users.

Why Use a UUID Validator Online

A browser-based UUID validator online requires no setup, no library imports, and no script execution. You don't need to write a regex, spin up a Python environment, or install a package. Just paste your UUIDs and get instant results. Because the tool runs entirely in your browser, no data is ever sent to a server — your UUIDs stay private, which matters when they are production record IDs or security-sensitive identifiers.

This tool is most useful for developers debugging UUID-related errors in API integrations, QA engineers spot-checking data from third-party imports, database administrators auditing ID columns for data quality, and anyone who needs to quickly confirm whether a string from a log file, email, or Slack message is a real UUID before acting on it.

Frequently Asked Questions about UUID Validator

The nil UUID is a special UUID where all 128 bits are zero: 00000000-0000-0000-0000-000000000000. It is structurally a valid UUID but semantically represents "no UUID" — similar to null or zero in other contexts. Some systems use the nil UUID as a placeholder or sentinel value. The validator correctly identifies it as valid and labels it "Nil UUID" rather than assigning it a version number.
The 32-character compact form without hyphens (e.g. 550e8400e29b41d4a716446655440000) is a common alternative representation used in databases and some APIs to save storage or avoid parsing overhead. This validator automatically expands compact UUIDs to the standard hyphenated format before checking, so both forms are accepted and produce identical validation results.
The variant bits (bits 64–65 of the 128-bit UUID) define the internal layout and interpretation of the remaining bits. The RFC 4122 standard requires the "10xx" bit pattern, encoded as hex 8, 9, a, or b in the 17th character. Other variants include NCS backward-compatible (legacy systems), Microsoft COM (used in Windows GUIDs before RFC 4122), and Reserved. Almost all UUIDs you encounter in modern software will be RFC 4122 compliant.
Yes, completely free. There are no usage limits, no account required, and no paid tiers. You can validate a single UUID or paste hundreds of lines for bulk validation without any restriction. The tool is ad-supported on the Oneyfy site, but all validation functionality is fully available at no cost.
No. All validation runs entirely in your browser using JavaScript. No network request is made when you click Validate. Your UUIDs never leave your device and are not logged, stored, or transmitted anywhere. You can verify this by opening your browser's Network DevTools tab and confirming no requests are made during validation — this is especially important if you're validating production record IDs or identifiers that map to sensitive data.
Yes. The tool is fully responsive and works on modern mobile browsers including Chrome for Android and Safari for iOS. You can paste UUIDs from your mobile clipboard, tap Validate, and see results in the same detailed format as on desktop. The results list is scrollable on narrow screens, so bulk validation is practical even on a phone.
Yes. The validator reads the version nibble from position 13 and reports whatever version it finds — v1 through v8 and beyond. UUID v7 (time-ordered, from RFC 9562) and v8 (custom/vendor-specific) are both detected and displayed correctly. The structural format check (32 hex digits in 8-4-4-4-12 groups) is the same regardless of version, so any structurally valid UUID of any version will pass format validation.
The "Invalid format" error means the input string does not match the UUID pattern — it's not 32 hexadecimal characters in the correct grouping. Common causes include: extra or missing characters, a typo that introduced a non-hex character (like g, h, or a space), a truncated UUID copied incompletely, or a different identifier format (like a CUID, NanoID, or MongoDB ObjectId) that is not a UUID.