Skip to content

Gratis ULID-generator — genereer & decodeer ULID's

Genereer, decodeer en converteer ULID's online — gratis en 100% in je browser. Haal de tijdstempel uit elke ULID, zet ULID om naar UUID en terug, genereer in batch, met monotone modus. Niets gaat ooit naar een server.

Geen tracking Draait in je browser Gratis
Elke ULID wordt lokaal gegenereerd met de cryptografische RNG van je browser (crypto.getRandomValues). Er wordt niets geüpload, gelogd of opgeslagen.

Elke ULID gebruikt verse 80-bit willekeurigheid.

Wat is een ULID?

Een ULID — Universally Unique Lexicographically Sortable Identifier — is een 128-bit identificator die is gemaakt om een praktische zwakte van de willekeurige UUIDv4 te verhelpen, terwijl hij diens beste eigenschap behoudt: je kunt er overal een genereren, zonder centrale coördinator, en erop vertrouwen dat hij uniek is. Het verschil is dat een ULID sorteerdbaar is op tijd. Hij wordt weergegeven als 26 tekens Crockford Base32, opgesplitst in twee delen: de eerste 10 tekens zijn een 48-bit tijdstempel die milliseconden sinds de Unix-epoche telt, en de laatste 16 tekens zijn 80 bits cryptografisch veilige willekeurigheid. Zet de tijd vooraan, codeer hem in een volgorde-behoudend alfabet, en de identificator sorteert chronologisch als een gewone string.

Die ene ontwerpkeuze heeft buitenproportionele gevolgen voor databases. Een willekeurige UUIDv4-primaire sleutel belandt bij elke insert op een onvoorspelbare plek in een B-tree-index, wat de index fragmenteert, de cache laat thrashen en de schrijfprestaties langzaam laat verslechteren naarmate een tabel groeit. Een ULID belandt, omdat hij een tijdprefix heeft, elke keer op of nabij het einde van de index — inserts blijven sequentieel, de index blijft compact, en range-scans over een tijdvenster worden goedkoop. Je krijgt de coördinatievrije generatie van een UUID en de insertlokaliteit van een automatisch oplopend geheel getal, zonder een raadbare sequentiële teller bloot te stellen.

De coderingsdetails zijn doelbewust. Crockford Base32 sluit de letters I, L, O en U uit, zowel om visuele verwarring met de cijfers 1 en 0 te vermijden als om de string bij invoer hoofdletterongevoelig te maken. Het resultaat is 26 tekens zonder koppeltekens die veilig in een URL, een bestandsnaam of een request-header kunnen worden geplaatst zonder escaping — merkbaar korter dan de vorm met 36 tekens en koppeltekens van een UUID. De 48-bit tijdstempel raakt nog lang niet op: hij kan data tot het jaar 10889 weergeven voordat de millisecondeteller overloopt.

ULID's zijn niet voor alles het juiste gereedschap. De ingebedde tijdstempel onthult wanneer een record is aangemaakt, wat een voordeel is voor debuggen en ordenen maar een klein informatielek als je dat liever niet blootgeeft. En als je stack vastzit aan het UUID-type, geef je misschien de voorkeur aan UUIDv7, dat hetzelfde idee met tijdprefix toepast binnen het standaard UUID-formaat. Maar wanneer je korte, URL-veilige, sorteerdbare identificatoren wilt die je op elke node kunt aanmaken en waar je een tijdstempel uit kunt teruglezen, is een ULID een uitstekende standaard — en omdat het slechts 128 bits is, kun je hem altijd van en naar een UUID converteren met het tabblad Converteren van deze tool.

// Browser / Node with the `ulid` package
import { ulid, decodeTime } from 'ulid';

const id = ulid();          // e.g. 01KVT0F720ZK9N4T2QX7VR8WMC
const ts = decodeTime(id);  // 1782210600000  ->  2026-06-23T10:30:00.000Z

// Monotonic factory: strictly increasing within the same millisecond
import { monotonicFactory } from 'ulid';
const next = monotonicFactory();
next(1782210600000); // 01KVT0F720ZK9N4T2QX7VR8WMC
next(1782210600000); // 01KVT0F720ZK9N4T2QX7VR8WMD
next(1782210600000); // 01KVT0F720ZK9N4T2QX7VR8WME

Belangrijkste functies

Genereren, decoderen en converteren op één pagina

Drie tabbladen dekken de hele ULID-workflow: maak nieuwe ULID's aan, decodeer een bestaande om de tijdstempel te lezen, en converteer verliesvrij tussen ULID en UUID. De meeste concurrerende tools doen alleen het eerste; hier leeft de volledige heen-en-terugconversie op één pagina.

Tijdstempeldecoder

Plak een willekeurige ULID en lees de exacte milliseconde waarop hij is aangemaakt — getoond in UTC, in je lokale tijd en als ruwe Unix-milliseconden — plus het 80-bit willekeurigheidssegment. Controleer wanneer een identificator is aangemaakt zonder databasequery.

Verliesvrije ULID ↔ UUID-conversie

Een ULID en een UUID zijn allebei 128 bits, dus de conversie is exact en omkeerbaar. Het tabblad Converteren detecteert automatisch welk formaat je hebt geplakt en produceert het andere, zodat je een sorteerdbare ULID en een UUID-getypeerde kolom of API kunt overbruggen zonder ook maar één bit te verliezen.

Monotone modus

Strikte ordening nodig, zelfs voor ID's die in dezelfde milliseconde zijn aangemaakt? De monotone modus verhoogt de willekeurigheid zodat elke ULID gegarandeerd groter is dan de vorige, wat een strakke insertlus perfect gesorteerd houdt.

Batchgeneratie

Maak tot 50 ULID's tegelijk aan en kopieer de hele set met Alles kopiëren. Ideaal voor het seeden van testfixtures, bulkinserts of het vullen van een opzoektabel zonder vijftig keer te klikken.

Aangepaste tijdstempel

Bed een specifiek moment in plaats van nu in — handig voor deterministische testgegevens of voor het terugdateren van records tijdens een migratie terwijl je de sorteerdbare eigenschap behoudt.

Cryptografisch veilige willekeurigheid

De 80 willekeurige bits komen uit crypto.getRandomValues, de CSPRNG van de browser — nooit Math.random — zodat elke ULID onvoorspelbaar is en botsingen binnen dezelfde milliseconde verdwijnend onwaarschijnlijk zijn.

100% privé, alleen in de browser

Elke ULID wordt volledig op je apparaat gegenereerd, gedecodeerd en geconverteerd. Geen netwerkverzoeken, geen logging, geen opslag — controleer het zelf in DevTools → Netwerk. Identificatoren bereiken nooit een derde partij.

ULID-voorbeelden

Genereer één enkele ULID

Modus: Standaard · Aantal: 1
01KVT0F720ZK9N4T2QX7VR8WMC

Een ULID is 26 tekens Crockford Base32. De eerste 10 tekens coderen een 48-bit tijdstempel in milliseconden en de laatste 16 coderen 80 bits cryptografisch veilige willekeurigheid getrokken uit crypto.getRandomValues. Omdat de tijdstempel vooraan staat en Base32 de bytevolgorde behoudt, sorteren later gegenereerde ULID's altijd na eerdere wanneer je ze als gewone strings vergelijkt — geen aparte index nodig. Klik op Kopiëren om de waarde te pakken; klik nogmaals op Genereer voor een nieuwe.

Decodeer een ULID om de tijdstempel te lezen

01ARYZ6S41TSV4RRFFQ69G5FAV
Tijdstempel (UTC): 2016-07-30T22:36:16.385Z · Willekeurigheid: TSV4RRFFQ69G5FAV

Decoderen draait de eerste 10 tekens terug naar de 48-bit milliseconde-waarde die bij aanmaak werd ingebed — hier 1469918176385 ms, wat 2016-07-30T22:36:16.385Z is. Dit is het canonieke voorbeeld uit de ULID-specificatie. Het tabblad Decoderen toont de tijdstempel in UTC en in je lokale tijd, de ruwe Unix-milliseconden en het 80-bit willekeurigheidssegment, zodat je precies kunt nagaan wanneer een identificator werd aangemaakt zonder enige databasequery.

Converteer een ULID naar een UUID

01KVT0F720ZK9N4T2QX7VR8WMC
019ef407-9c40-fcd3-5268-57e9f784728c

Een ULID en een UUID zijn allebei precies 128 bits, dus de conversie is verliesvrij en volledig omkeerbaar — dezelfde bits worden simpelweg hergecodeerd van Crockford Base32 naar hexadecimaal met koppeltekens. Het tabblad Converteren detecteert automatisch of je een ULID of een UUID hebt geplakt en zet hem om naar de andere vorm. Zo kun je ULID's opslaan in een UUID-kolom of een ULID doorgeven aan een systeem dat alleen UUID spreekt, en weer terugconverteren wanneer je de sorteerdbare string opnieuw nodig hebt.

Genereer monotone ULID's in batch

Modus: Monotoon · Aantal: 3 (zelfde milliseconde)
01KVT0F720ZK9N4T2QX7VR8WMC
01KVT0F720ZK9N4T2QX7VR8WMD
01KVT0F720ZK9N4T2QX7VR8WME

Wanneer veel ID's binnen dezelfde milliseconde worden aangemaakt, delen gewone ULID's de tijdprefix van 10 tekens maar zijn hun willekeurige staarten ongeordend. De monotone modus lost dit op: binnen één milliseconde verhoogt hij de vorige willekeurigheid met één, zodat elke ULID strikt groter is dan de vorige en een batch perfect gesorteerd blijft. Merk op dat de drie waarden alleen in het laatste teken verschillen (C, D, E) — ideaal voor inserts met hoge doorvoer waar de volgorde moet blijven kloppen, zelfs bij snelheden onder de milliseconde.

Genereer een ULID voor een specifieke datum

Aangepaste tijd: 2026-06-23 10:30:00 UTC
01KVT0F720… (tijdcomponent 01KVT0F720)

Stel een aangepaste tijdstempel in en de generator bedt dat exacte moment in plaats van nu in, terwijl hij de willekeurigheid nog steeds uit een veilige RNG vult. De tijdcomponent van 10 tekens voor 2026-06-23T10:30:00.000Z is 01KVT0F720. Dit is handig om testfixtures te seeden met deterministische, tijdgeordende identificatoren, of om records terug te dateren tijdens een migratie terwijl je de sorteerdbare eigenschap intact houdt.

Zo gebruik je de ULID-generator

  1. 1

    Kies een generatiemodus

    De modus Standaard geeft elke ULID verse 80-bit willekeurigheid. De modus Monotoon garandeert dat ULID's die binnen dezelfde milliseconde zijn aangemaakt strikt oplopen — kies hem voor inserts met hoge doorvoer waar de volgorde moet blijven kloppen, zelfs bij snelheden onder de milliseconde.

  2. 2

    Stel aantal, schrijfwijze en (optioneel) een aangepaste tijd in

    Genereer 1 tot 50 ULID's tegelijk. De uitvoer is standaard in HOOFDLETTERS — de canonieke ULID-vorm — of schakel naar kleine letters. Laat de tijd leeg om nu te stempelen, of stel een aangepaste tijdstempel in om een specifiek moment in te bedden voor fixtures of teruggedateerde records.

  3. 3

    Genereer en kopieer

    Klik op Genereer ULID. Gebruik Kopiëren op elke afzonderlijke waarde, of Alles kopiëren om de hele batch te pakken als tekst gescheiden door regeleinden, klaar om in code, een seed-bestand of een spreadsheet te plakken.

  4. 4

    Decodeer een ULID om de tijdstempel te lezen

    Plak op het tabblad Decoderen een willekeurige ULID om de 48-bit aanmaaktijdstempel in UTC en lokale tijd te extraheren, plus de ruwe Unix-milliseconden en de 80-bit willekeurigheid — volledig in je browser, zonder query nodig.

  5. 5

    Converteer tussen ULID en UUID

    Plak op het tabblad ULID ↔ UUID een ULID of een UUID; de tool detecteert de invoer automatisch en converteert verliesvrij naar het andere formaat. Sla ULID's op in UUID-kolommen, of geef een ULID door aan een UUID-only systeem en converteer terug wanneer je de sorteerdbare string nodig hebt.

Common Errors

ULID's binnen dezelfde milliseconde als geordend behandelen

Gewone ULID's die binnen één milliseconde zijn aangemaakt delen de tijdprefix maar hebben ongeordende willekeurige staarten, dus hun onderlinge volgorde ligt niet vast. Als je bij die snelheid afhankelijk bent van strikte ordening, gebruik dan de monotone modus.

✗ Fout 
Standaardmodus, 3 ID's in één ms  →  volgorde binnen de ms is willekeurig
✓ Correct 
Monotone modus, 3 ID's in één ms  →  …WMC < …WMD < …WME

Verwachten dat een geconverteerde ULID een geldige UUIDv4 is

Een ULID naar UUID-vorm converteren hercodeert dezelfde 128 bits; het stelt de UUID-versie- en variantvelden niet in. Het resultaat is een geldige 128-bit UUID-string, maar wordt niet als versie 4 of 7 herkend als een bibliotheek die bits inspecteert.

✗ Fout 
uuid.version(ulidToUuid(id))  →  niet 4 (bits zijn die van de ULID)
✓ Correct 
Behandel het als een ondoorzichtige 128-bit waarde, of genereer een echte UUIDv7

Met de hand een kleine i, l, o in een ULID typen

Crockford Base32 sluit I, L, O en U uit. Decoders mappen I en L naar 1 en O naar 0, maar die letters met de hand in een ULID typen is foutgevoelig. Kopieer ULID's in plaats van ze opnieuw te typen.

✗ Fout 
01ARYZ6S41TSV4RRFFQ69G5FAO  →  dubbelzinnige O
✓ Correct 
01ARYZ6S41TSV4RRFFQ69G5FAV  →  alleen canonieke tekens

Waarvoor ULID's worden gebruikt

Primaire databasesleutels die gesorteerd blijven
Gebruik ULID's als primaire sleutels om de coördinatievrije generatie van een UUID te combineren met de insertlokaliteit van een auto-increment geheel getal. Omdat ze een tijdprefix hebben, worden nieuwe rijen nabij het einde van een B-tree-index toegevoegd in plaats van te verspreiden zoals UUIDv4, waardoor inserts snel blijven en de index compact naarmate de tabel groeit.
Gedistribueerde systemen zonder centrale sequentie
Genereer identificatoren op elke node — service, edge-worker of client — zonder gedeelde teller en zonder botsingscoördinatie, en sorteer toch achteraf alles op aanmaaktijd. ULID's geven microservices een unieke, geordende sleutel zonder een databaseroundtrip om hem toe te wijzen.
Event-logs en bericht-ID's
Stempel events, logregels of wachtrijberichten met monotone ULID's zodat ze in strikte chronologische volgorde blijven, zelfs wanneer er veel binnen dezelfde milliseconde worden geproduceerd. Een tijdvenster range-scannen wordt een eenvoudige stringvergelijking.
URL-veilige publieke identificatoren
Een ULID is 26 tekens zonder koppeltekens en met een URL-veilig alfabet, dus hij past in een pad, een bestandsnaam of een header zonder escaping en is korter dan een UUID van 36 tekens. Decodeer later de ingebedde tijdstempel om te zien wanneer de resource is aangemaakt.
Brug naar een UUID-only systeem
Werk je met een databasekolom of een API die alleen UUID's accepteert? Genereer sorteerdbare ULID's, converteer ze naar UUID-vorm voor opslag of transport, en converteer terug wanneer je de compacte sorteerdbare string nodig hebt — de 128-bit waarde blijft in beide richtingen exact behouden.
Deterministische testfixtures
Seed tests met ULID's op gekozen tijdstempels via de optie voor aangepaste tijd, zodat fixtures reproduceerbaar en al tijdgeordend zijn. Decodeer ze in assertions om de aanmaaktijd te verifiëren die je code heeft vastgelegd.

Hoe ULID's werken

128-bit indeling: 48-bit tijd + 80-bit willekeurigheid
Een ULID is precies 128 bits. De hoge 48 bits zijn een Unix-tijdstempel in milliseconden; de lage 80 bits zijn willekeurig. Gecodeerd in Crockford Base32 met 5 bits per teken is dat 10 tekens voor de tijd en 16 voor de willekeurigheid — 26 tekens in totaal. Het beginteken is altijd 7 of lager, omdat 48 bits de bovenste groep van 5 bits niet vullen.
Crockford Base32-codering
ULID's gebruiken het Crockford Base32-alfabet (0–9 en A–Z zonder I, L, O en U). Het weglaten van die vier letters voorkomt verwarring met de cijfers 1 en 0 en laat decoders de string hoofdletterongevoelig behandelen, waarbij I en L bij invoer naar 1 en O naar 0 worden gemapt. Het alfabet is geordend, en dat is wat de gecodeerde string op dezelfde manier laat sorteren als de onderliggende bits.
Lexicografische sorteerbaarheid
Omdat de tijdstempel de meest significante component is en het Base32-alfabet de volgorde behoudt, levert het vergelijken van twee ULID's als strings hetzelfde resultaat op als het vergelijken van hun 128-bit waarden, wat hetzelfde resultaat oplevert als het vergelijken van hun aanmaaktijden. Dit is wat een gewone ORDER BY of array-sortering chronologische volgorde laat produceren zonder extra index.
Monotoniciteit binnen een milliseconde
De monotone optie van de ULID-spec houdt de ordening stabiel voor ID's die in dezelfde milliseconde zijn aangemaakt: de willekeurigheid van het eerste ID in een milliseconde wordt normaal gegenereerd, en elk later ID in die milliseconde is de vorige willekeurige waarde plus één. Deze tool implementeert dat door de 80-bit willekeurigheid te verhogen als een big-endian geheel getal.
Veilige willekeurigheid via crypto.getRandomValues
De 80 willekeurige bits worden gevuld uit crypto.getRandomValues, de Web Crypto-CSPRNG, niet Math.random. Met 80 bits entropie houdt het genereren van zelfs miljoenen ULID's in dezelfde milliseconde de botsingskans verwaarloosbaar klein.
ULID ↔ UUID is een pure hercodering
Converteren tussen ULID en UUID verandert geen enkele bit — het hercodeert dezelfde 128 bits van Crockford Base32 naar hexadecimaal met koppeltekens of terug. Daardoor is de heen-en-terugconversie exact: een ULID die naar een UUID en terug wordt geconverteerd is byte voor byte identiek aan het origineel. Let op: de bytes van een ULID stellen de UUID-versie- en variantvelden niet in, dus de resulterende UUID is een geldige 128-bit waarde maar geen versie-getagde UUIDv4 of v7.

Aanbevolen werkwijzen voor ULID's

Gebruik de monotone modus voor inserts met hoge doorvoer
Als je systeem meer dan één identificator per milliseconde kan aanmaken en je op de volgorde vertrouwt, genereer dan monotone ULID's. Gewone ULID's zijn ongeordend binnen een milliseconde; monotone zijn strikt oplopend, zodat een batch gesorteerd blijft, hoe snel je ze ook aanmaakt.
Sla ULID's compact op
Een ULID is 128 bits — sla hem op als 16 binaire bytes of een UUID-getypeerde kolom in plaats van als een tekstveld van 26 tekens wanneer ruimte en indexgrootte ertoe doen. Converteer alleen aan de randen naar de Base32-string, waar mensen of URL's hem zien. Het tabblad Converteren van deze tool geeft je de UUID-vorm voor opslag.
Onthoud dat de tijdstempel zichtbaar is
Een ULID onthult zijn aanmaaktijd aan iedereen die hem kan lezen. Dat is geweldig voor debuggen en ordenen, maar als het blootgeven van de aanmaaktijd een zorg is — bijvoorbeeld in een publieke identificator — weeg dat lek dan af, of gebruik een volledig willekeurige UUIDv4 waar ordening niet uitmaakt.
Genereer altijd met een CSPRNG
De uniciteitsgarantie hangt af van het onvoorspelbaar zijn van de 80 willekeurige bits. Gebruik een cryptografisch veilige bron zoals crypto.getRandomValues, zoals deze tool doet — nooit Math.random, waarvan de voorspelbaarheid identificatoren zou kunnen laten botsen of raadbaar zou kunnen maken.
Kies bewust ULID of UUIDv7
Beide geven tijdgeordende 128-bit ID's. Kies ULID voor de kortste URL-veilige string; kies UUIDv7 wanneer je in het standaard UUID-formaat met versie- en variantbits moet blijven. Standaardiseer per systeem op één, en gebruik het tabblad Converteren wanneer je de grens moet oversteken.

ULID — veelgestelde vragen

Wat is een ULID?
Een ULID (Universally Unique Lexicographically Sortable Identifier) is een 128-bit identificator die is ontworpen als een beter sorteerdbaar, compacter alternatief voor een UUID. Hij wordt geschreven als 26 tekens Crockford Base32: de eerste 10 tekens bevatten een 48-bit tijdstempel in milliseconden sinds de Unix-epoche, en de overige 16 tekens bevatten 80 bits willekeurigheid. Omdat de tijdstempel het meest significante deel is en Base32 de volgorde behoudt, sorteren later aangemaakte ULID's altijd na eerdere wanneer je ze als gewone strings vergelijkt — een kolom met ULID's is dus van nature tijdgeordend. Het Crockford-alfabet sluit bewust de letters I, L, O en U uit om verwarring met cijfers te vermijden en de string hoofdletterongevoelig en URL-veilig te houden. ULID's zijn geïntroduceerd om een praktisch probleem met willekeurige UUIDv4 op te lossen: willekeurige identificatoren verspreiden zich over een database-index, wat de insertprestaties schaadt, terwijl een ULID met tijdprefix elke keer aan het einde van de index belandt.
ULID versus UUID — welke moet ik gebruiken?
Gebruik een ULID wanneer je identificatoren wilt die zowel uniek zijn als van nature sorteerdbaar op aanmaaktijd; gebruik een klassieke UUIDv4 wanneer je specifiek een ondoorzichtige, volledig willekeurige identificator zonder ingebedde tijdstempel nodig hebt. De belangrijkste verschillen: een ULID is 26 tekens Base32 tegenover de 36 tekens met koppeltekens van een UUID, dus ULID's zijn korter en URL-veilig zonder escaping. Een ULID codeert zijn aanmaaktijd, wat een UUIDv4 niet doet — handig voor ordening en debuggen, maar het is goed om te weten als je liever niet blootgeeft wanneer een record is gemaakt. Beide zijn 128 bits en beide vermijden coördinatie, dus het botsingsrisico is voor allebei verwaarloosbaar. Als je stack standaardiseert op UUID's maar je toch tijdordening wilt, biedt UUIDv7 (uit de UUID-generator) een vergelijkbaar ontwerp met tijdprefix in UUID-formaat — of je genereert hier ULID's en converteert ze naar UUID met het tabblad Converteren.
Zijn ULID's sorteerdbaar?
Ja — dat is de bepalende eigenschap. Omdat de 48-bit milliseconde-tijdstempel de eerste 10 tekens beslaat en Crockford Base32 de lexicografische volgorde behoudt, sorteert het sorteren van ULID's als gewone strings ze op aanmaaktijd. Dit geldt in elk systeem dat strings byte voor byte vergelijkt: een database-ORDER BY, een gesorteerde set, een bestandslijst of een eenvoudige array-sortering. De praktische winst is databaseprestatie: tijdgeordende sleutels worden aan het einde van een B-tree-index toegevoegd in plaats van willekeurig te verspreiden zoals UUIDv4, waardoor inserts snel blijven en de index compact. Binnen één milliseconde is de volgorde van gewone ULID's willekeurig, dus als je strikte ordening nodig hebt, zelfs voor ID's die binnen dezelfde milliseconde zijn aangemaakt, gebruik dan de monotone modus, die de willekeurigheid verhoogt zodat elke waarde gegarandeerd groter is dan de vorige.
Hoe decodeer ik de tijdstempel van een ULID?
Plak de ULID in het tabblad Decoderen en de tool haalt direct de ingebedde aanmaaktijd eruit, volledig in je browser. Hij leest de eerste 10 tekens, converteert ze van Crockford Base32 terug naar een 48-bit geheel getal van milliseconden sinds de Unix-epoche, en toont dat moment in UTC en je lokale tijd samen met de ruwe Unix-milliseconde-waarde. De canonieke ULID 01ARYZ6S41TSV4RRFFQ69G5FAV decodeert bijvoorbeeld naar 1469918176385 ms, oftewel 2016-07-30T22:36:16.385Z. De overige 16 tekens zijn de 80-bit willekeurigheid en hebben geen betekenis om te decoderen. Op deze manier de tijdstempel lezen is handig voor debuggen, controleren wanneer een record is aangemaakt, of even verifiëren dat een identificator echt een ULID is — zonder databasequery.
Wat is een monotone ULID?
Een monotone ULID garandeert strikte ordening, zelfs voor identificatoren die binnen dezelfde milliseconde zijn gegenereerd. Gewone ULID's die in één milliseconde zijn aangemaakt delen dezelfde tijdprefix van 10 tekens, maar hun 80-bit willekeurige staarten zijn onafhankelijk, dus hun onderlinge volgorde ligt niet vast. Monotone generatie lost dit op: de eerste ULID in een gegeven milliseconde krijgt verse willekeurigheid, en elke volgende ULID in diezelfde milliseconde wordt geproduceerd door de vorige willekeurigheid met één te verhogen. Het resultaat is een reeks waarin elke waarde strikt groter is dan de vorige, zodat een batch die in een strakke lus wordt ingevoegd perfect gesorteerd blijft. Dit is belangrijk voor systemen met hoge doorvoer — event-logs, berichtenwachtrijen, bulkimports — waar veel rijen sneller kunnen worden aangemaakt dan de millisecondeklok tikt en je toch een stabiele, oplopende sleutel nodig hebt.
Is deze ULID-generator veilig en privé?
Ja op beide punten. De willekeurigheid in elke ULID komt uit crypto.getRandomValues, de cryptografisch veilige generator voor willekeurige getallen van de browser — nooit Math.random — zodat de 80 willekeurige bits onvoorspelbaar zijn en de kans dat twee ULID's binnen dezelfde milliseconde botsen verdwijnend klein is. Net zo belangrijk: alles draait lokaal. De ULID's worden volledig op je apparaat gegenereerd, gedecodeerd en geconverteerd. Er wordt niets geüpload, gelogd of opgeslagen, en je kunt het bevestigen door DevTools te openen en het tabblad Netwerk stil te zien blijven terwijl je op Genereer klikt. Die privacy-eigenschap is precies de reden om identificatoren in de browser aan te maken in plaats van op een server die in principe een kopie van elke uitgegeven waarde zou kunnen bewaren.
Wat is het verschil tussen ULID en UUIDv7?
Zowel ULID als UUIDv7 zijn tijdgeordende 128-bit identificatoren die een milliseconde-tijdstempel vooraan plaatsen, dus beide sorteren op aanmaaktijd en beide indexeren efficiënt — het kernidee is hetzelfde. Het verschil zit in formaat en codering. Een ULID wordt weergegeven als 26 tekens Crockford Base32 zonder koppeltekens, wat korter en URL-veilig is; UUIDv7 wordt weergegeven in de standaard hexadecimale UUID-indeling van 36 tekens met koppeltekens en draagt versie- en variantbits op vaste posities, dus het is een volledig geldige RFC 9562-UUID die elke UUID-bibliotheek accepteert. Kies UUIDv7 wanneer je in het UUID-ecosysteem moet blijven (een UUID-databasekolom, een UUID-getypeerde API); kies ULID wanneer je de kortste sorteerdbare string wilt. Omdat beide 128 bits zijn, kun je hier een ULID genereren en hem met het tabblad Converteren naar UUID-vorm omzetten, of een UUIDv7 genereren met de UUID-generator.

Gerelateerde tools

Alle tools bekijken →

Bcrypt-hashgenerator & -verifier

Beveiligingstools

Genereer en verifieer bcrypt-wachtwoordhashes online — instelbare kostenfactor, $2b$/$2a$/$2y$-prefixes. 100% in je browser; je wachtwoord wordt nooit geüpload.

JWT decoderen — online JWT-decoder

Beveiligingstools

Decodeer JWT-tokens direct in je browser. Inspecteer header, payload, signature, vervaldatum en claims. 100% privé — je token verlaat je apparaat nooit.

JWT-encoder & generator

Beveiligingstools

Gratis online JWT-generator & encoder. Bouw de header en payload en onderteken direct met HS256, RS256 of ES256. 100% in de browser — je secret en sleutel verlaten je apparaat nooit.

Gratis JWT-secretgenerator — HS256/384/512

Beveiligingstools

Genereer een sterk, RFC-correct JWT-secret voor HS256/384/512 — 100% in je browser, nooit naar een server gestuurd. base64url, base64 of hex; kopieer voor .env.

Online MD5 Hash Generator & Checksum Tool

Beveiligingstools

Genereer MD5-, SHA-256-, SHA-1- en SHA-512-hashes gratis in je browser. Hash tekst of bestanden, verifieer checksums en kopieer resultaten. Geen account nodig.

Willekeurig wachtwoord genereren — online generator

Beveiligingstools

Genereer direct sterke willekeurige wachtwoorden — gratis, 100% in je browser. Stel lengte en tekens in, batch tot 50 met entropie-analyse.