UUID format validator
The UUID format validator checks whether a value follows the standard 36-character, hyphenated UUID representation and explains exactly why malformed input fails.
Run — free
A successful result returns the normalized lowercase canonical form, the variant encoded by the clock-sequence bits, and the version encoded in the UUID. It accepts uppercase or lowercase hexadecimal letters without silently accepting braces, compact strings, misplaced separators, or non-hexadecimal characters, making it useful for debugging identifiers before they enter an API, database, log pipeline, or validation rule.
What this UUID validator checks
A UUID is 128 bits, but people and systems usually exchange it as 36 visible characters arranged in five groups: eight hexadecimal characters, then four, four, four, and twelve, separated by hyphens. This validator checks that exact representation. It verifies the total length, confirms that every separator appears in the correct position, and rejects any character outside hexadecimal digits and hyphens. Hexadecimal letters can be uppercase or lowercase because their case does not change the underlying bits. Spaces, braces, a URN prefix, compact 32-character values, and trailing punctuation are not silently removed. That strict boundary is valuable when you are testing the contract of an API or database field: an input either matches the documented UUID text form or receives a reason that points to the structural problem. A successful response includes valid as true and provides a lowercase canonical value that can be used for stable comparisons, cache keys, fixtures, and logs. Validation is deterministic and does not query a registry, generate a replacement identifier, or claim that the UUID exists in any external system.
How variant and version are decoded
UUID metadata is encoded inside the identifier rather than looked up. The version is the hexadecimal nibble at the start of the third group, so the validator converts that nibble to an integer from 0 through 15 and reports it directly. Common assigned versions include time-based version 1, name-based versions 3 and 5, random version 4, reordered-time version 6, Unix-time version 7, and custom version 8. The variant comes from the leading bits at the start of the fourth group. A leading zero bit is reported as ncs; the bit pattern 10 is reported as rfc_4122, the family used by modern RFC UUID layouts; 110 is reported as microsoft; and 111 is reported as future. Reporting the bits is different from enforcing one application profile. A structurally correct UUID can carry a reserved version or a legacy variant, so this tool describes what the input encodes instead of pretending every well-formed value must be version 4. Your application can then apply its own policy to the returned fields.
Canonicalization, errors, and practical use
Canonicalization changes only hexadecimal letter case: the five groups and all digits remain untouched, while A through F become lowercase. This means two accepted spellings of the same 128-bit value produce exactly the same canonical string. The validator does not trim whitespace or rewrite an almost-correct value, because automatic cleanup can hide a broken serialization boundary. Instead, an empty value, a non-string value, the wrong character count, misplaced hyphens, and illegal characters produce distinct explanatory messages. That behavior makes the capability suitable for import gates, form diagnostics, test fixtures, and support tools where the cause matters as much as a yes-or-no result. Send one candidate in the text field; the aliases uuid and value are also accepted for integration convenience. The operation costs $0.002 per item through the API and runs with no network access, randomness, clock, model, or persistent storage. It checks syntax and embedded metadata only. It cannot determine uniqueness, ownership, database presence, generation quality, or whether a syntactically valid identifier is appropriate for a particular protocol.
What you can do with it
Guard an API boundary
Reject malformed path parameters before a database query and preserve a canonical identifier for downstream comparisons.
Debug imported identifiers
Find incorrect lengths, separators, or characters in CSV and migration data with a reason a developer can act on.
Inspect UUID metadata
Confirm the encoded variant and version when auditing whether producers follow an application's identifier policy.
FAQ
What UUID text formats are accepted?
The standard 36-character 8-4-4-4-12 hyphenated form is accepted, with uppercase or lowercase hexadecimal letters.
Does it accept braces, URN prefixes, or compact UUIDs?
No. Those representations are rejected so an integration can enforce one unambiguous text contract.
What does canonical form mean here?
It is the same UUID in the standard hyphenated grouping with every hexadecimal letter converted to lowercase.
Does a valid result prove that the UUID exists or is unique?
No. The result proves only that the string is structurally well formed and reports the metadata encoded in its bits.
How much does validation cost?
Each API item costs $0.002. The deterministic validator performs no network request and can also run in the browser.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/dev/uuid-validate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"550E8400-E29B-41D4-A716-446655440000"}'const res = await fetch("https://api.kit.forhosting.com/dev/uuid-validate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "550E8400-E29B-41D4-A716-446655440000"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/uuid-validate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "550E8400-E29B-41D4-A716-446655440000"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/uuid-validate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"550E8400-E29B-41D4-A716-446655440000"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"550E8400-E29B-41D4-A716-446655440000"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/uuid-validate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "550E8400-E29B-41D4-A716-446655440000"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.uuid_validate",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |