Skip to content

Online UUID-generator — v1, v4, v5, v7 met batchmodus

Gratis UUID-generator voor v1, v4, v5 en v7. Decodeer en valideer elke UUID. Genereer tot 50 stuks. Geen account nodig, 100% in je browser.

Geen tracking Draait in je browser Gratis
Alle UUID's worden lokaal in je browser gegenereerd. Er wordt niets verzonden of opgeslagen.
Gecontroleerd op RFC 9562-naleving en structurele correctheid — Go Tools Engineering Team · Mar 22, 2026

Wat is een UUID?

Een UUID (Universally Unique Identifier) is een 128-bit globaal unieke identificator die is gestandaardiseerd in RFC 9562 (IETF, mei 2024). UUID's zijn ontworpen om botsingsvrije ID's te genereren in gedistribueerde systemen zonder centrale coördinatie. UUID's zijn het meest gebruikte identificatorformaat in moderne software — ze worden gebruikt als primaire sleutels in databases, voor het traceren van API-verzoeken, sessiebeheer en microservice-architecturen.

UUID's worden weergegeven als 32 hexadecimale tekens in het canonieke 8-4-4-4-12-formaat, zoals `550e8400-e29b-41d4-a716-446655440000`. De specificatie wordt beheerd door de IETF; RFC 9562 vervangt het eerdere RFC 4122 (2005) en introduceert officieel UUID-versies 6, 7 en 8.

Er zijn vijf veelgebruikte UUID-versies. Versie 1 (v1) slaat de huidige tijdstempel en het MAC-adres van het genererende apparaat op, waardoor elke UUID uniek is in zowel tijd als ruimte. Versie 3 (v3) en versie 5 (v5) zijn deterministisch — ze hashen een naamruimte en een naam met respectievelijk MD5 of SHA-1 en produceren altijd dezelfde UUID voor dezelfde invoer. Versie 4 (v4) is de meest gebruikte: 122 bits worden gevuld met cryptografisch veilige willekeurige gegevens, wat meer dan 5,3 × 10³⁶ mogelijke waarden oplevert (RFC 9562, sectie 5.4). Versie 7 (v7) is de nieuwste standaard: zoals RFC 9562, sectie 5.7 stelt, "UUID versie 7 bevat een tijdgeordend waardeveld afgeleid van de Unix Epoch tijdstempelbron" — een 48-bit milliseconde-tijdstempel gecombineerd met willekeurige gegevens levert UUID's op die zowel uniek als van nature sorteerdbaar zijn op aanmaaktijd.

UUID's zijn essentieel in gedistribueerde systemen, databases, API's en overal waar unieke identificatoren nodig zijn zonder centrale coördinatie. Ze elimineren het risico op ID-botsingen tussen onafhankelijke systemen, waardoor ze ideaal zijn voor microservices, event sourcing en multi-tenant architecturen.

Deze tool genereert alle UUID-versies volledig in je browser via de Web Crypto API — er worden geen UUID's naar een server verzonden. Anders dan servergebaseerde generators zijn er geen uploads, geen logging en geen dataopslag. Veilig te gebruiken voor productiesleutels, API-identificatoren en beveiligingsgevoelige toepassingen. Je kunt ook bestaande UUID's decoderen en valideren om hun versie, variant en ingebedde gegevens te inspecteren.

UUID's zijn nauw verbonden met andere ontwikkelaarstools. UUID v1 en v7 bevatten Unix-tijdstempels direct in hun structuur, UUID v3 en v5 gebruiken MD5- en SHA-1-hashes als basis, en UUID-strings worden vaak vervoerd in JSON-payloads die je het beste kunt inspecteren met een JSON formatter. Voor een uitgebreide introductie tot het UUID-formaat, de versies en praktische gebruiksscenario's, lees onze complete UUID-gids. Als je kiest tussen UUID v4, v7, ULID en Snowflake-ID's voor een primaire databasesleutel, bekijk dan onze ID-selectievergelijking.

// Generate a UUID v4 using the Web Crypto API
const uuid = crypto.randomUUID();
console.log(uuid);
// → '550e8400-e29b-41d4-a716-446655440000'

// Manual v4 generation with crypto.getRandomValues()
function generateUUIDv4() {
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);
  bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
  bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 10
  const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
  return `${hex.slice(0,8)}-${hex.slice(8,12)}-${hex.slice(12,16)}-${hex.slice(16,20)}-${hex.slice(20)}`;
}

Belangrijkste functies

UUID v7-ondersteuning (RFC 9562)

Genereer het nieuwste UUID v7-formaat met ingebedde Unix-tijdstempels voor tijdgeordende, database-vriendelijke identificatoren. Een van de weinige online tools die de RFC 9562-standaard ondersteunen.

UUID-decoder en -validator

Verwerk elke UUID om de versie, variant, tijdstempel (v1/v7), kloksequentie en node-informatie te tonen. Valideer direct of een string een correct geformatteerde UUID is.

Ondersteuning voor meerdere versies

Genereer UUID's in vijf versies — v1 (tijdgebaseerd), v3 (MD5), v4 (willekeurig), v5 (SHA-1) en v7 (tijdgeordend willekeurig) — allemaal conform RFC 9562.

Batchgeneratie

Genereer tot 50 unieke UUID's tegelijk. Elke UUID wordt onafhankelijk gegenereerd met volledige cryptografische willekeurigheid of correcte versiespecifieke codering.

Meerdere uitvoerformaten

Geef UUID's uit in standaard kleine letters, HOOFDLETTERS, zonder koppeltekens of met accolades {GUID} — precies het formaat dat je systeem of framework vereist.

Cryptografisch veilig

Gebruikt de Web Crypto API (crypto.getRandomValues()) voor echte willekeurige getallengeneratie — dezelfde standaard die moderne browsers en beveiligingstools gebruiken.

100% in je browser

Alle UUID's worden lokaal in je browser gegenereerd. Er wordt niets naar een server verzonden — je gegenereerde identificatoren blijven volledig privé.

UUID-versievergelijking

Kies de juiste UUID-versie voor je gebruikssituatie.

Versie Basis Sorteerbaar Privacy Geschikt voor
v1 Tijdstempel + MAC-adres Op aanmaaktijd Stelt MAC en tijd bloot Oudere systemen die tijdgebaseerde volgorde vereisen
v4 122 bits cryptografisch willekeurig Nee Volledig anoniem Algemeen gebruik — meest gebruikte versie
v5 SHA-1-hash van naamruimte + naam Nee Deterministisch, reproduceerbaar Consistente ID's van bekende invoer (URL's, DNS)
v7 Unix-tijdstempel (ms) + willekeurig Op aanmaaktijd Stelt alleen aanmaaktijd bloot Moderne databases — sorteerdbaar, indexvriendelijk (RFC 9562)

UUID versus andere ID-formaten

ULID

26 tekens, Crockford Base32

Lexicografisch sorteerdbaar zoals UUID v7, maar gebruikt Crockford Base32-codering (26 tekens versus 36). UUID v7 is nu het IETF-gestandaardiseerde alternatief met bredere tooling-ondersteuning.

nanoid

21 tekens, URL-veilig alfabet

Korter en URL-veilig, ideaal als compactheid belangrijk is. Geen formele standaard — mist native databasetypen en cross-platform-bibliotheken die UUID wel heeft.

CUID2

Variabele lengte, alfanumeriek

Ontworpen voor horizontale schaling met botsingsresistentie. Minder breed geadopteerd dan UUID; geen native database-ondersteuning. Overweeg UUID v7 voor gestandaardiseerde tijdgesorteerde ID's.

UUID-versievoorbeelden

UUID v4 (willekeurig)

550e8400-e29b-41d4-a716-446655440000

De meest gebruikte versie. 122 bits cryptografische willekeurigheid levert meer dan 5,3 × 10^36 mogelijke waarden op — geschikt voor vrijwel elke situatie waarbij uniciteit vereist is zonder coördinatie.

UUID v7 (tijdgeordend)

01906b5e-4a3e-7234-8f56-b8c12d4e5678

Combineert een 48-bit Unix-tijdstempel in milliseconden met willekeurige gegevens. UUID's sorteren chronologisch, waardoor ze ideaal zijn als primaire databasesleutels waarbij indexlokaliteit van belang is. Aanbevolen voor nieuwe projecten boven v1 en v4.

UUID v1 (tijdgebaseerd)

6ba7b810-9dad-11d1-80b4-00c04fd430c8

Slaat een 60-bit tijdstempel en het 48-bit MAC-adres van het genererende apparaat op. Garandeert uniciteit in tijd en ruimte, maar kan hardware-identiteitsinformatie blootstellen. Vervangen door v6/v7 in RFC 9562.

UUID v5 (SHA-1 naamgebaseerd)

886313e1-3b8a-5372-9b90-0c9aee199e5d

Deterministische UUID gegenereerd door de DNS-naamruimte te hashen met de naam 'python.org' via SHA-1. Dezelfde naamruimte en naam produceren altijd dezelfde UUID, waardoor v5 ideaal is voor reproduceerbare identificatoren.

Zo gebruik je het

  1. 1

    Selecteer de UUID-versie

    Kies uit v1 (tijdgebaseerd), v3 (MD5 naamgebaseerd), v4 (willekeurig), v5 (SHA-1 naamgebaseerd) of v7 (tijdgeordend willekeurig). Elke versie heeft een ander doel — v4 is het meest gebruikelijk voor algemeen gebruik.

  2. 2

    Stel de opties in

    Voor v3 en v5 selecteer je een naamruimte (DNS, URL, OID, X.500 of aangepast) en voer je een naam in om te hashen. Stel het aantal in van 1 tot 50 en kies een uitvoerformaat: standaard kleine letters, HOOFDLETTERS, zonder koppeltekens of met accolades {GUID}.

  3. 3

    Genereer UUID's

    Klik op de knop Genereer. Elke UUID wordt aangemaakt via de Web Crypto API (crypto.getRandomValues()) voor cryptografische beveiliging. Versiespecifieke velden zoals tijdstempels (v1/v7) en hashes (v3/v5) worden correct geëncodeerd.

  4. 4

    Kopieer en gebruik

    Klik op de knop Kopieer naast een UUID om die naar je klembord te kopiëren, of gebruik Alles kopiëren om alle gegenereerde UUID's in één keer te kopiëren. Ga naar het tabblad Decoderen om de versie, variant, tijdstempel en andere ingebedde informatie van een bestaande UUID te analyseren.

Veelvoorkomende gebruiksscenario's

Primaire databasesleutels
Gebruik UUID v4 of v7 als unieke primaire sleutels zonder coördinatie tussen databaseknooppunten. UUID v7 is hiervoor bijzonder geschikt, omdat de tijdgeordende structuur de B-tree-indexprestaties verbetert.
Gedistribueerde systemen
Genereer onafhankelijk unieke identificatoren over microservices, berichtenwachtrijen en event-sourcingsystemen. UUID's elimineren de behoefte aan een gecentraliseerde ID-generatieservice.
API-ontwikkeling
Maak unieke verzoek-ID's, correlatie-ID's en idempotentiesleutels voor RESTful en GraphQL-API's. UUID's maken het eenvoudig om verzoeken te traceren over gedistribueerde servicegrenzen heen.
Sessie- en tokenbeheer
Genereer unieke sessie-identificatoren en tijdelijke tokens voor authenticatiestromen. UUID's bieden voldoende uniciteit om sessieduplicaten te voorkomen bij grote gebruikersaantallen.
Testen en ontwikkeling
Genereer snel testgegevens, mock-identificatoren en unieke fixture-ID's voor geautomatiseerd testen. Met batchgeneratie is het eenvoudig om ontwikkelingsdatabases en testsuites te vullen.

Technische details

UUID-structuur
Een UUID is 128 bits (16 bytes) weergegeven als 32 hexadecimale tekens in het 8-4-4-4-12-formaat. Bits 48-51 (het 13e hexadecimale teken) coderen het versienummer. Bits 64-65 coderen het variantfield, dat de UUID-indeling identificeert. De resterende bits bevatten versiespecifieke payload: tijdstempel, willekeurige gegevens of hash-uitvoer.
Versiebits
Bits 48-51 (de hoge nibble van de 7e byte) coderen de UUID-versie: 0001 = v1 (tijdgebaseerd), 0011 = v3 (MD5 naamgebaseerd), 0100 = v4 (willekeurig), 0101 = v5 (SHA-1 naamgebaseerd), 0110 = v6 (hergeordend tijdgebaseerd), 0111 = v7 (Unix-epochetijd). Deze vier bits worden altijd expliciet ingesteld tijdens generatie.
Variantfield
Bits 64-65 (de twee meest significante bits van de 9e byte) definiëren de variant. Het patroon 10x geeft RFC 4122/9562-UUID's aan (de grote meerderheid). Patroon 110 geeft Microsoft-GUID's aan met mixed-endian byte-volgorde. Patroon 0xx geeft NCS achterwaarts compatibele UUID's aan (legacy). Patroon 111 is gereserveerd voor toekomstig gebruik.
RFC 9562-standaard
RFC 9562, gepubliceerd in mei 2024, vervangt RFC 4122 als de definitieve UUID-specificatie. Het introduceert officieel UUID-versies 6, 7 en 8. Versie 6 herschikt v1-velden voor sorteerbaarheid. Versie 7 gebruikt een 48-bit Unix-tijdstempel in milliseconden plus willekeurige gegevens, waardoor het de aanbevolen versie is voor nieuwe tijdgebaseerde UUID's. Versie 8 biedt een formaat voor aangepaste, implementatiespecifieke UUID's. RFC 9562 veroudert ook officieel v1 ten gunste van v6/v7.

Aanbevolen werkwijzen

Kies de juiste versie
Gebruik v4 voor algemene unieke identificatoren waarbij geen volgorde of determinisme nodig is. Gebruik v7 voor primaire databasesleutels — de tijdgeordende eigenschap levert aanzienlijk betere indexprestaties. Gebruik v5 als je deterministische ID's nodig hebt afgeleid van namen (geef de voorkeur aan v5 boven v3 voor sterkere hashing).
Gebruik UUID v7 voor primaire databasesleutels
De tijdgeordende structuur van UUID v7 houdt B-tree-invoegingen sequentieel, waardoor indexfragmentatie met ongeveer 90% afneemt ten opzichte van willekeurige v4-UUID's. Dit leidt tot snellere schrijfbewerkingen, kleinere indexen en betere cache-benutting. De meeste moderne databases (PostgreSQL 17+, MySQL 8.0+) hebben native UUID-ondersteuning geoptimaliseerd voor dit patroon.
Gebruik UUID's nooit als beveiligingstokens
UUID's zijn ontworpen voor uniciteit, niet voor geheimhouding. UUID v1 stelt de generatietijdstempel en het MAC-adres bloot. UUID v4 heeft slechts 122 bits entropie met een voorspelbare structuur. Gebruik voor beveiligingstokens, API-sleutels of sessiegeheimen een speciale CSPRNG om 128 of 256 bits pure willekeurige gegevens te genereren zonder de UUID-structuuroverhead.
Valideer vóór verwerking
Valideer UUID-formaat altijd met een reguliere expressie voordat je ze verwerkt of opslaat. Wijs onjuist gevormde invoer af op systeemgrenzen — API-eindpunten, formulierinzendingen en database-invoer. Dit voorkomt injectieaanvallen, gegevensbeschadiging en moeilijk te debuggen fouten door ongeldige identificatoren die zich door je systeem verspreiden.

Veelgestelde vragen

Wat is een UUID?
Een UUID (Universally Unique Identifier) is een 128-bit identificator gestandaardiseerd door RFC 9562. Hij wordt weergegeven als 32 hexadecimale tekens verdeeld in vijf groepen gescheiden door koppeltekens, in het formaat 8-4-4-4-12 — bijvoorbeeld 550e8400-e29b-41d4-a716-446655440000. UUID's zijn ontworpen om globaal uniek te zijn zonder een centrale registratie-autoriteit. De term GUID (Globally Unique Identifier) is de naam die Microsoft gebruikt voor hetzelfde concept en heeft hetzelfde formaat. UUID's worden veelvuldig gebruikt in databases, gedistribueerde systemen, API's en softwareontwikkeling overal waar unieke identificatoren nodig zijn. Met meer dan 5,3 × 10^36 mogelijke v4-UUID's is de kans op een duplicaat astronomisch klein, waardoor ze veilig zijn voor onafhankelijke generatie in niet-gecoördineerde systemen.
Wat zijn de verschillen tussen UUID-versies?
UUID v1 slaat een 60-bit tijdstempel en het 48-bit MAC-adres van het apparaat op, waardoor uniciteit in tijd en ruimte gegarandeerd is, maar hardware-identiteit mogelijk blootgesteld wordt. UUID v3 hasht een naamruimte en naam met MD5 om een deterministische UUID te produceren — dezelfde invoer levert altijd dezelfde uitvoer. UUID v4 vult 122 van zijn 128 bits met cryptografisch veilige willekeurige gegevens, waardoor het de meest gebruikte versie is voor algemene unieke identificatoren. UUID v5 is identiek aan v3 maar gebruikt SHA-1 in plaats van MD5, wat sterkere hashbotsingsresistentie biedt. UUID v7, geïntroduceerd in RFC 9562 (mei 2024), bevat een 48-bit Unix-tijdstempel in milliseconden gevolgd door willekeurige bits, waardoor UUID's worden geproduceerd die zowel uniek als van nature sorteerdbaar zijn op aanmaaktijd. De versiekeuze hangt af van je vereisten: v4 voor eenvoud, v5 voor determinisme en v7 voor tijdsorteerdbare databasesleutels.
Wanneer gebruik ik UUID v4 versus v7?
UUID v4 is de meest populaire versie en een uitstekende standaardkeuze. Het genereert 122 bits pure willekeurigheid, vereist geen configuratie en werkt overal. Gebruik v4 als je gewoon een unieke identificator nodig hebt en volgorde niet belangrijk is. UUID v7 is de betere keuze als UUID's worden gebruikt als primaire databasesleutels of gesorteerd moeten worden op aanmaaktijd. Omdat v7 een millisecondeprecisie-tijdstempel inbedt in de meest significante bits, sorteren v7-UUID's van nature in chronologische volgorde. Dit verbetert de B-tree-indexprestaties aanzienlijk — invoegingen gaan altijd naar het einde van de index in plaats van willekeurige posities, waardoor paginasplitsingen en fragmentatie met tot wel 90% afnemen. Voor nieuwe projecten in 2026 is de algemene aanbeveling om v7 te gebruiken voor databasesleutels en v4 voor al het andere. Beide versies zijn even uniek en cryptografisch willekeurig in hun willekeurige gedeelten.
Hoe groot is de kans op een UUID-botsing?
UUID v4 heeft 122 willekeurige bits, wat 2^122 (ongeveer 5,3 × 10^36) mogelijke waarden geeft. Om 50% kans te hebben op ten minste één botsing, zou je ongeveer 2,71 × 10^18 UUID's moeten genereren — dat zijn 2,71 triljard. Ter vergelijking: als je een miljard UUID's per seconde zou genereren, zou het 86 jaar duren om een botsing­skans van 50% te bereiken. Bij realistischere generatiesnelheden is de kans verwaarloosbaar klein. Het genereren van 10 miljoen UUID's levert bijvoorbeeld een botsing­skans op van ruwweg 1 op 10^22. In de praktijk zijn hardwarestoringen, softwarefouten en menselijke fouten allemaal miljarden keren waarschijnlijker als oorzaak van dubbele ID's dan UUID v4-botsingen. De berekening is gebaseerd op de verjaardagsformule: p(n) ≈ n² / (2 × 2^122).
Wat is het verschil tussen UUID en GUID?
UUID (Universally Unique Identifier) en GUID (Globally Unique Identifier) zijn in essentie hetzelfde. GUID is de term die door Microsoft is bedacht en die voornamelijk wordt gebruikt in Windows-, .NET-, COM- en SQL Server-omgevingen. UUID is de standaardterm gedefinieerd door RFC 9562 (en zijn voorganger RFC 4122) en wordt gebruikt in de meeste andere contexten, waaronder Linux, Java, Python, PostgreSQL en webontwikkeling. Beide gebruiken hetzelfde 128-bit formaat weergegeven als 32 hexadecimale tekens in het 8-4-4-4-12-patroon. Het enige kleine verschil is dat Microsoft-tools GUID's soms weergeven in hoofdletters met accolades, zoals {550E8400-E29B-41D4-A716-446655440000}, terwijl UUID's conventioneel in kleine letters zonder accolades worden weergegeven. Deze tool ondersteunt beide formaten via de uitvoerformaatkeuze — kies het formaat Accolades {GUID} voor Microsoft-stijl uitvoer.
Is UUID v4 cryptografisch veilig?
Wanneer gegenereerd met crypto.getRandomValues() of een equivalente CSPRNG (Cryptografisch Veilige Pseudo-Willekeurige Getallengenerator), bevat UUID v4 122 bits cryptografisch veilige willekeurige gegevens. Deze tool gebruikt de Web Crypto API, die entropie trekt uit de veilige willekeurige bron van het besturingssysteem. UUID's mogen echter niet worden gebruikt als beveiligingstokens, wachtwoorden of encryptiesleutels. Hoewel 122 bits willekeurigheid voorspelling onmogelijk maakt, hebben UUID's een voorspelbare structuur — de versienibble (4) en variantbits zijn vast en publiek bekend. Gebruik voor beveiligingstokens specifieke API's zoals crypto.getRandomValues() met volledige 128 of 256 bits entropie, of gebruik gevestigde tokenformaten zoals JWT. Gebruik UUID's voor identificatie, niet voor beveiliging.
Zo valideer je een UUID-formaat
Een geldige UUID komt overeen met het reguliere-expressiepatroon: ^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$ (hoofdletterongevoelig). Dit patroon controleert het 8-4-4-4-12 hexadecimale formaat, controleert of het versieteken (positie 15) tussen 1 en 7 ligt, en verifieert dat de variantnibble (positie 20) begint met 8, 9, a of b (wat de RFC 4122/9562-variant aangeeft). In JavaScript kun je valideren met: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid). De meeste programmeertalen hebben ook ingebouwde UUID-verwerking — bijvoorbeeld Python's uuid.UUID(), Java's UUID.fromString() en Go's uuid.Parse(). Valideer UUID's altijd op systeemgrenzen voordat je ze opslaat of verwerkt om injectieaanvallen en gegevensbeschadiging te voorkomen.
Zijn UUID's goede primaire databasesleutels? (Prestaties, veiligheid en beste versie)
Ja, UUID's zijn veilig en steeds populairder als primaire databasesleutels, waarbij UUID v7 de aanbevolen versie is. De belangrijkste voordelen: (1) UUID's kunnen overal worden gegenereerd — clients, servers of edge-functies — zonder een roundtrip naar de database, wat offline-first en gedistribueerde architecturen mogelijk maakt. (2) UUID's voorkomen enumeratieaanvallen omdat ze geen opeenvolgende integers zijn. (3) UUID's vereenvoudigen het samenvoegen van gegevens over systemen heen omdat ID's nooit botsen. UUID v7 is de beste versie voor primaire sleutels omdat de tijdgeordende structuur B-tree-indexen sequentieel houdt, waardoor paginasplitsingen, schrijfversterking en indexfragmentatie met tot wel 90% worden verminderd ten opzichte van willekeurige v4-UUID's. De afwegingen: UUID's gebruiken 16 bytes versus 4-8 bytes voor integers, waardoor opslag en geheugen voor indexen toenemen. In MySQL/InnoDB, waar de primaire sleutel de geclusterde index is, kunnen willekeurige v4-UUID's aanzienlijke prestatievermindering veroorzaken — v7 lost dit op door ervoor te zorgen dat invoegingen altijd worden toegevoegd aan het einde van de index, wat prestaties haalt vergelijkbaar met auto-increment integers. PostgreSQL slaat UUID's native op in 16 bytes met het uuid-type. Voor de meeste moderne toepassingen wegen de voordelen van globaal unieke, coördinatievrije ID-generatie ruimschoots op tegen de extra opslagkosten.
Wat is een naamruimte-UUID (v3/v5)?
Een naamruimte-UUID is een voorgedefinieerde of aangepaste UUID die dient als scope voor het genereren van deterministische v3- en v5-UUID's. RFC 4122 definieert vier standaard naamruimte-UUID's: DNS (6ba7b810-9dad-11d1-80b4-00c04fd430c8), URL (6ba7b811-9dad-11d1-80b4-00c04fd430c8), OID (6ba7b812-9dad-11d1-80b4-00c04fd430c8) en X.500 DN (6ba7b814-9dad-11d1-80b4-00c04fd430c8). Wanneer je een naamruimte-UUID combineert met een naamstring, hasht het v3- of v5-algoritme ze samen om een deterministische UUID te produceren — dezelfde naamruimte plus naam levert altijd dezelfde UUID op. Dit is handig als je reproduceerbare identificatoren nodig hebt afgeleid van betekenisvolle namen. Het hashen van de DNS-naamruimte met 'example.com' levert bijvoorbeeld altijd dezelfde v5-UUID op. Je kunt ook elke geldige UUID gebruiken als aangepaste naamruimte voor het eigen deterministische ID-schema van je toepassing.
Wat is de UUID-nulwaarde?
De nul-UUID (ook wel de zero UUID genoemd) is 00000000-0000-0000-0000-000000000000 — alle 128 bits op nul gezet. Deze is gedefinieerd in RFC 9562, sectie 5.9 als een speciale UUID die de afwezigheid van een waarde kan vertegenwoordigen, vergelijkbaar met null of None in programmeertalen. De nul-UUID is handig als schildwachtwaarde, standaardwaarde in configuratiesystemen of tijdelijke aanduiding in databaserecords waarbij een UUID-veld niet leeg mag zijn maar er nog geen echte waarde bestaat. RFC 9562 definieert ook de max-UUID: ffffffff-ffff-ffff-ffff-ffffffffffff (alle bits op één), die kan dienen als grenmarkering. Belangrijk voorbehoud: gebruik de nul-UUID nooit als echte identificator — hij is niet uniek. Sommige UUID-bibliotheken en databases kunnen nul-UUID's afwijzen of speciaal behandelen, dus zorg ervoor dat je systeem ze consistent behandelt. Documenteer altijd of nul-UUID's worden geaccepteerd in je API-contracten en databaseschema's.
Wat is UUID v7 en waarom zou ik het gebruiken?
UUID v7 is de nieuwste UUID-versie gedefinieerd in RFC 9562 (mei 2024). Hij bevat een 48-bit Unix-tijdstempel in milliseconden in de meest significante bits, gevolgd door cryptografisch willekeurige gegevens. Dit ontwerp produceert UUID's die globaal uniek, chronologisch sorteerdbaar en zeer efficiënt zijn als primaire databasesleutels. Anders dan UUID v1, dat ook een tijdstempel bevat, gebruikt v7 een eenvoudiger Unix-epocheformaat en stelt het je MAC-adres niet bloot. De tijdgeordende structuur vermindert B-tree-indexfragmentatie met tot wel 90% ten opzichte van willekeurige UUID v4, wat resulteert in snellere invoegingen, kleinere indexen en betere cache-treffratio's. Voor nieuwe projecten die starten in 2026 is UUID v7 de aanbevolen keuze voor elk scenario waarbij tijdgebaseerde volgorde vereist is — met name primaire databasesleutels, event-logs en gedistribueerde berichtenwachtrijen.
Zo decodeer je een UUID
Een UUID decoderen betekent de structurele informatie extraheren die in de 128 bits is opgeslagen. Elke UUID bevat een versiefield (bits 48-51) dat aangeeft hoe hij is gegenereerd, en een variantfield (bits 64-65) dat de UUID-standaard aangeeft waaraan hij voldoet. Buiten deze gemeenschappelijke velden bevatten verschillende versies verschillende gegevens: UUID v1 en v6 bevatten een 60-bit tijdstempel en een 48-bit node (MAC-adres); UUID v7 bevat een 48-bit Unix-tijdstempel in milliseconden; UUID v3 en v5 bevatten een afgekapte hash van een naamruimte en naam. Om een UUID te decoderen, plak je hem in het tabblad Decoderen van deze tool. De versie, variant, tijdstempel (voor tijdgebaseerde versies) en geldigheid worden direct weergegeven. Programmatisch kun je decoderen door de hexadecimale tekens te verwerken en bitsgewijze bewerkingen toe te passen om elk veld te extraheren volgens de RFC 9562-specificatie.
UUID versus ULID versus nanoid — welke kies je?
UUID, ULID en nanoid dienen hetzelfde fundamentele doel — het genereren van unieke identificatoren — maar verschillen in formaat, sorteerbaarheid en standaardisatie. UUID is de meest breed geadopteerde standaard (RFC 9562), native ondersteund door vrijwel alle databases, talen en frameworks. UUID v7 biedt tijdgebaseerde sortering in het universele 128-bit formaat van 36 tekens. ULID (Universally Unique Lexicographically Sortable Identifier) dateert van vóór UUID v7 en gebruikt Crockford Base32-codering om een sorteerdbare string van 26 tekens te produceren. Nu UUID v7 bestaat als IETF-standaard, is het belangrijkste voordeel van ULID — sorteerbaarheid — beschikbaar in het universele UUID-formaat. nanoid genereert kortere identificatoren (standaard 21 tekens) met een URL-veilig alfabet, ideaal als stringlengte belangrijk is en je geen cross-systeem interoperabiliteit nodig hebt. Voor de meeste toepassingen is UUID v4 (algemeen gebruik) of UUID v7 (databasesleutels) de aanbevolen keuze vanwege universele tooling-ondersteuning, native databasetypen en formele standaardisatie.
Ik bouw een microservice en moet kiezen tussen UUID v4 en v7 voor mijn PostgreSQL-primaire sleutels — welke gebruik ik en waarom?
Gebruik UUID v7 voor PostgreSQL-primaire sleutels. UUID v7 bevat een millisecondeprecisie-Unix-tijdstempel in de meest significante bits, waardoor gegenereerde ID's van nature chronologisch gesorteerd zijn. Dit houdt je B-tree-indexen sequentieel — invoegingen worden altijd toegevoegd aan het einde in plaats van op willekeurige posities, waardoor paginasplitsingen en indexfragmentatie met tot wel 90% afnemen ten opzichte van willekeurige UUID v4. PostgreSQL 17+ heeft native uuid-type-ondersteuning geoptimaliseerd voor dit patroon. UUID v4 is nog steeds prima voor niet-geïndexeerde identificatoren zoals correlatie-ID's of sessietokens waarbij sorteervolgorde niet van belang is.
Mijn team debatteert over UUID's versus auto-increment integers als database-ID's — wat zijn de echte afwegingen?
Auto-increment integers zijn kleiner (4-8 bytes versus 16 bytes), sneller te vergelijken en produceren van nature sequentiële indexen. Ze vereisen echter een gecentraliseerde sequentie (de database), waardoor ze problematisch zijn in gedistribueerde systemen, offline-first-apps en datamigrations. UUID's kunnen overal worden gegenereerd — clients, edge-functies, meerdere databases — zonder coördinatie. Ze voorkomen ook enumeratieaanvallen (gebruikers kunnen /users/124 niet raden om andere records te vinden). De opslagoverhead is reëel maar meestal acceptabel: een UUID-index is ongeveer 2× zo groot als een integer-index. Voor de meeste moderne toepassingen biedt UUID v7 het beste van beide werelden — globaal uniek, coördinatievrij en van nature sorteerdbaar zoals auto-increments.

Gerelateerde tools

Alle tools bekijken →