UUID-validator

Valideer losse UUID's of hele lijsten lokaal in je browser volgens RFC 9562.

Geen uploadsGeen registratieDirect resultaat
Strikte RFC 9562 + versiefiltersBulkdiagnose per regelJSON- & CSV-auditrapport
UUID's valideren
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis UUID-validator gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

Volledige RFC 9562 versiedekking

Valideert moderne UUIDv6-, UUIDv7- en UUIDv8-identifiers naast klassieke v1- tot en met v5-sleutels, plus de speciale Nil-UUID (allemaal nullen) en Max-UUID (allemaal enen) die door verouderde RFC 4122-regexen worden afgekeurd.

Bulk classificatie & filtering per regel

Verwerkt duizenden door regeleindes gescheiden strings in één keer, voorziet elke rij van de gedetecteerde versie, variant-prefix en exacte syntaxfout, en exporteert opgeschoonde, geldige sets.

Strikte variant- & canonieke syntaxcontrole

Controleert de exacte hexadecimale 8-4-4-4-12-structuur van 36 tekens en onderscheidt standaard RFC 9562 variant-bits (10xx) van verouderde Microsoft COM/GUID's (110x), NCS (0xxx) en niet-hexadecimale tokens.

100% lokale batchverwerking in de browser

Voert syntaxverificatie, normalisatie naar kleine letters en filtering volledig binnen je browsertabblad uit, zonder databasedumps, klant-ID's of logbestanden naar externe servers te uploaden.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
Volledige RFC 9562 versiedekking Valideert moderne UUIDv6-, UUIDv7- en UUIDv8-identifiers naast klassieke v1- tot en met v5-sleutels, plus de speciale Nil-UUID (allemaal nullen) en Max-UUID (allemaal enen) die door verouderde RFC 4122-regexen worden afgekeurd. Beperkte opties zonder geavanceerde aanpassing
Bulk classificatie & filtering per regel Verwerkt duizenden door regeleindes gescheiden strings in één keer, voorziet elke rij van de gedetecteerde versie, variant-prefix en exacte syntaxfout, en exporteert opgeschoonde, geldige sets. Vereist externe tools of handmatige bewerking
Privacy & Gegevensverwerking 100% lokale verwerking in je browser (geen uploads) Uploadt gegevens naar externe cloudservers
Prijsmodel & Accountvereisten 100% gratis voor altijd zonder registratie Vereist accountregistratie of betaald abonnement
Hoe het werkt

Hoe UUID-validator te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Plak te controleren UUID's of upload een bestand

Voer één UUID in, plak een batch met meerdere regels uit applicatielogs of SQL-exports, of sleep een lokaal tekst- of CSV-bestand naar de validator.

2

Controleer syntax, versie & variant per regel

Bekijk het batchoverzicht met het aantal geldige versus ongeldige regels, de versieclassificatie per rij (v1 t/m v8, Nil, Max) en specifieke foutmeldingen voor afgekeurde regels.

3

Filter en exporteer opgeschoonde UUID's

Filter de resultaten op geldige RFC 9562-identifiers of een specifieke UUID-versie en kopieer of download vervolgens de naar kleine letters genormaliseerde lijst.

Praktijkvoorbeeld bulk UUID-validatie: invoerlijsten en diagnostische uitvoer

Kort antwoord: Bij het valideren van een lijst met meerdere regels wordt elke getrimde rij gecontroleerd op de canonieke hexadecimale 8-4-4-4-12-structuur van 36 tekens, eerst vergeleken met de speciale Nil- en Max-constanten en vervolgens getest om te bevestigen dat nibble 13 versie 1-8 codeert en nibble 17 begint met de RFC 9562 10xx variant-bits.

Datapipelines en API-ingestieprocessen krijgen vaak te maken met gemengde ID-formaten: moderne UUIDv7-sleutels, legacy GUID's in hoofdletters, sentinel-constanten en niet-UUID-tokens zoals ULID's. Hieronder zie je een concrete batch van zeven regels die laat zien hoe RFC 9562-validatie elk geval classificeert.

Voorbeeldinvoer met meerdere regels

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF
550e8400-e29b-91d4-a716-446655440000
550e8400-e29b-41d4-c716-446655440000
01ARZ3NDEKTSV4RRFFQ69G5FAV

Classificatierapport per rij

[
  {
    "line": 1,
    "input": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f",
    "valid": true,
    "classification": "UUIDv7",
    "variant": "RFC 9562 (10xx)",
    "normalized": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f"
  },
  {
    "line": 2,
    "input": "550e8400-e29b-41d4-a716-446655440000",
    "valid": true,
    "classification": "UUIDv4",
    "variant": "RFC 9562 (10xx)",
    "normalized": "550e8400-e29b-41d4-a716-446655440000"
  },
  {
    "line": 3,
    "input": "00000000-0000-0000-0000-000000000000",
    "valid": true,
    "classification": "Nil UUID (RFC 9562 Section 5.9)",
    "variant": "Nil (all zeros)",
    "normalized": "00000000-0000-0000-0000-000000000000"
  },
  {
    "line": 4,
    "input": "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF",
    "valid": true,
    "classification": "Max UUID (RFC 9562 Section 5.10)",
    "variant": "Max (all ones)",
    "normalized": "ffffffff-ffff-ffff-ffff-ffffffffffff"
  },
  {
    "line": 5,
    "input": "550e8400-e29b-91d4-a716-446655440000",
    "valid": false,
    "error": "Invalid version nibble '9' at position 15 (expected 1-8, or Nil/Max)"
  },
  {
    "line": 6,
    "input": "550e8400-e29b-41d4-c716-446655440000",
    "valid": false,
    "error": "Non-RFC-9562 variant nibble 'c' (110x Microsoft legacy GUID; expected 8, 9, a, or b)"
  },
  {
    "line": 7,
    "input": "01ARZ3NDEKTSV4RRFFQ69G5FAV",
    "valid": false,
    "error": "Invalid length (26 chars, Crockford Base32 ULID pattern; expected 36-char 8-4-4-4-12 hex)"
  }
]

Gefilterde canonieke export

Bij het exporteren van geldige rijen worden hexadecimale hoofdletters genormaliseerd naar canonieke kleine letters volgens RFC 9562 sectie 4:

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
ffffffff-ffff-ffff-ffff-ffffffffffff

RFC 9562 validatieregels, regex-randgevallen en canonieke normalisatie

Kort antwoord: Een RFC 9562-conforme validator kan niet vertrouwen op verouderde RFC 4122 [1-5]-regexen: hij moet versies 1 tot en met 8 in combinatie met variant [89ab] accepteren, de Nil-UUID (allemaal nullen) en Max-UUID (allemaal enen) expliciet toestaan en hexadecimale hoofdletters normaliseren naar canonieke kleine letters voordat ze in string-geïndexeerde opslag belanden.

RFC 9562 (mei 2024) breidde de UUID-specificatie uit van vijf naar acht versies en legde twee grensconstanten formeel vast. Hierdoor schieten oudere validatiepatronen die nog steeds in veel validatiebibliotheken en API-gateways zitten tekort.

Waarom verouderde RFC 4122-regexen falen bij moderne sleutels

Validatoren van vóór 2024 dwingen doorgaans [1-5] af op het 13e hexadecimale cijfer en houden geen rekening met sentinel-waarden, waardoor geldige UUIDv6-, UUIDv7-, UUIDv8-, Nil- en Max-sleutels worden afgewezen. Een volledige, hoofdletterongevoelige reguliere expressie volgens RFC 9562 die de canonieke 8-4-4-4-12-syntax voor v1-v8 plus Nil en Max dekt, ziet er zo uit:

^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$

Wanneer je onvertrouwde invoer valideert in backend-runtimes zoals Python, Ruby of PCRE, veranker het einde van de string dan met \z (of \Z in Python re.fullmatch) in plaats van $. Het $-anker matcht namelijk ook direct vóór een afsluitend \n-regeleinde, waardoor payloads met newline-injectie door simpele stringcontroles kunnen glippen.

Database `uuid`-types versus strikte applicatieschema's

Een veelvoorkomende oorzaak van ingestiefouten in productie is het verschil tussen soepele databaseparsers en strikte API-schemavalidatoren:

  • Soepele 128-bits hex-parsers (bijv. PostgreSQL uuid): PostgreSQL accepteert elke reeks van 32 hexadecimale cijfers (met canonieke koppeltekens, optionele {...}-accolades of helemaal zonder koppeltekens), ongeacht het versie-nibble (0-f) of de variant-prefix (0xxx, 10xx, 110x, 111x). Verouderde Microsoft COM GUID's (110x-variant, hex c of d op positie 17) of willekeurige 128-bits MD5-hashes in een uuid-kolom worden zonder fouten via SQL ingevoegd.
  • Strikte RFC 9562-validatoren (OpenAPI, Zod, Rust uuid, Go google/uuid): Strikte API-schema's controleren de canonieke notatie van 36 tekens met koppeltekens en dwingen vaak variant 10xx en versies 1-8 (plus Nil/Max) af. Door SQL-exports in bulk te valideren voordat je ze aanbiedt aan strikte REST- of gRPC-services, vang je rijen met afwijkende varianten vroegtijdig af.

Canonieke normalisatie naar kleine letters

RFC 9562 sectie 4 schrijft voor dat parsers hoofdletters A-F als invoer moeten accepteren, maar bij uitvoer kleine letters a-f moeten produceren. Native binaire databasetypes van 16 bytes (UUID in PostgreSQL, BINARY(16) in MySQL) wissen het verschil tussen hoofd- en kleine letters automatisch, maar systemen die UUID's opslaan in VARCHAR(36), Redis-sleutels, DynamoDB-partitiesleutels of JSON-caches behandelen 550E8400-... en 550e8400-... als verschillende strings, tenzij ze tijdens de validatie naar kleine letters worden genormaliseerd.

UUID Validator vs. UUID Parser vs. UUID Generator: welke heb je nodig?

Kort antwoord: Gebruik de UUID Validator om de syntax te verifiëren, naleving van RFC 9562 te controleren, versies in bulklijsten te classificeren en schone ID's te exporteren. Gebruik de UUID Parser & Decoder om ingesloten UTC-tijdstempels en 128-bits velden uit een specifieke UUID te halen, of de UUID v4 Generator om nieuwe cryptografisch willekeurige identifiers aan te maken.

Kies de juiste UUID-tool van Utiliome op basis van je taak: bestaande lijsten controleren, interne bitvelden inspecteren of nieuwe sleutels genereren:

Functionaliteit UUID Validator (Deze tool) UUID Parser & Decoder UUID v4 Generator
Primair doel Enkele UUID's of batches met meerdere regels valideren en ongeldige invoer eruit filteren De binaire 128-bits indeling, node-ID en ingesloten UTC-tijdstempel van een UUID decoderen In bulk cryptografisch willekeurige (CSPRNG) UUIDv4-identifiers genereren
Bulklijstverwerking Ja — plak lijsten of upload bestanden, bekijk foutdiagnoses per regel en exporteer geldige sets Nee — ontworpen voor diepgaande bitveldinspectie van individuele identifiers Genereert nieuwe batches met willekeurige v4-sleutels; valideert geen externe invoer
Versiedekking Classificeert v1 t/m v8, Nil (0000...) en Max (ffff...) Decodeert bitstructuren voor v1 t/m v8, Nil en Max Genereert uitsluitend RFC 9562 UUIDv4 (gebruik de UUID v7, v6 & v1 Generator voor tijdgeordende sleutels)
Tijdstempelextractie Herkent of een sleutel tijdgebaseerd is (v1, v6, v7) zonder de datum zelf te decoderen Haalt exacte ISO-8601 UTC-datums, Unix-ms en Gregoriaanse ticks van 100 ns op Niet van toepassing (UUIDv4 bevat 122 willekeurige bits en geen tijdstempelgegevens)

Aanbevolen workflows voor ontwikkelaars

  • CSV-exports, logs of migratie-payloads opschonen: Plak je lijst hier om geldige RFC 9562-identifiers te scheiden van beschadigde strings, ULID's of verouderde niet-RFC GUID's en exporteer een schone lijst in kleine letters.
  • Onderzoeken wanneer een tijdgebaseerde sleutel is aangemaakt: Kopieer een geldige v1-, v6- of v7-identifier naar de UUID Parser & Decoder om de ingesloten UTC-aanmaaktijdstempel, kloksequentie en binaire 128-bits velden te inspecteren.
  • Nieuwe identifiers genereren: Gebruik de UUID v4 Generator voor onvoorspelbare willekeurige tokens, of de UUID v7, v6 & v1 Generator voor chronologisch sorteerbare primaire sleutels in databases.
Veelgestelde vragen

UUID-validator FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online uuid validator.

Zijn Nil (allemaal nullen) en Max (allemaal F'en) geldige UUID's volgens RFC 9562?

Ja. RFC 9562 sectie 5.9 definieert 00000000-0000-0000-0000-000000000000 als de Nil-UUID, en sectie 5.10 definieert ffffffff-ffff-ffff-ffff-ffffffffffff als de Max-UUID voor sentinel-waarden en bovengrenzen in bereikquery's, zelfs al vallen hun versie- en variant-nibbles buiten [1-8] en [89ab].

Waarom slaagt een Microsoft GUID wel in PostgreSQL, maar faalt deze bij strikte RFC 9562-validatie?

Verouderde Microsoft COM/DCOM GUID's kunnen de achterwaarts compatibele 110x-variant bevatten (hex c of d op het 17e hexadecimale cijfer) in plaats van de RFC 9562 10xx-variant (8, 9, a, b). Het native uuid-kolomtype van PostgreSQL accepteert elke 128-bits hexadecimale waarde zonder de versie- of variant-bits te controleren, terwijl strikte RFC 9562-validatoren varianten buiten 10xx afkeuren.

Maakt hexadecimaal in hoofdletters een UUID ongeldig?

Nee. RFC 9562 sectie 4 stelt dat parsers bij het inlezen van UUID's zowel hoofdletters A-F als kleine letters a-f hoofdletterongevoelig moeten accepteren. Generatoren en formatters zijn echter verplicht om canonieke kleine letters uit te voeren, zodat hoofdlettergevoelige string-indexen en hash-maps geen dubbele sleutels opslaan.

Waarom wijzen oudere regexen voor UUID-validatie UUID v7 en UUID v8 af?

Regex-patronen die zijn geschreven voor RFC 4122 (gepubliceerd in 2005) leggen [1-5] vast op het 13e hexadecimale cijfer, omdat vóór mei 2024 alleen de versies 1 tot en met 5 bestonden. Pas met RFC 9562 werden de herordende Gregoriaanse v6, de op Unix-epochtijd gesorteerde v7, de aangepaste v8 en de Max-UUID (allemaal enen) gestandaardiseerd.

Zijn ULID's, GUID's met accolades of hex-strings van 32 tekens zonder koppeltekens geldige canonieke UUID's?

Niet in canonieke tekstvorm. ULID's coderen 128 bits als 26 Crockford Base32-tekens in plaats van hexadecimaal, terwijl {...}-accolades, urn:uuid:-prefixen en strings van 32 tekens zonder koppeltekens alternatieve transportwrappers zijn. De canonieke UUID-syntax van RFC 9562 vereist strikt 36 tekens geformatteerd als 8-4-4-4-12 hexadecimale cijfers.