CUID Generator

Generate collision-resistant unique IDs (CUID v1)

Aantal

Gegenereerde CUIDs

Klik op Genereren om CUIDs te maken

CUID v1 is een legacy-formaat. Gebruik CUID2 voor nieuwe projecten.

Wat is CUID?

CUID (Collision-Resistant Unique Identifier) is een open-source algoritme voor het genereren van unieke ID's die goed werken in gedistribueerde systemen zonder een centrale coördinator. In tegenstelling tot een eenvoudige UUID is een CUID ontworpen om horizontaal schaalbaar te zijn — meerdere servers of browsertabbladen kunnen elk onafhankelijk ID's genereren met minimaal risico op botsingen.

Elke CUID begint met de kleine letter c, waardoor het formaat in één oogopslag herkenbaar is. De resterende tekens zijn allemaal kleine alfanumerieke tekens (base36), zodat een CUID URL-veilig is en direct als URL-padsegment of database-primaire sleutel kan worden gebruikt zonder extra codering.

De originele CUID-specificatie (v1) werd gemaakt door Eric Elliott en gepopulariseerd via het npm-pakket cuid. Het is nu vervangen door CUID v2, dat cryptografische beveiliging biedt. Deze pagina — en de bovenstaande generator — produceert CUID v1-ID's, het klassieke formaat dat nog steeds veel voorkomt in productiecodebases.

CUID-structuur

Een CUID v1 is ongeveer 25 tekens lang en bestaat uit vijf aaneengeschakelde segmenten, elk met een ander type entropie:

Voorbeeld: clrc4gkwz001ag2hs3k7f9m2q
cvoorvoegselAltijd de letter "c" — markeert een CUID
lrc4gkwztijdstempelMillisecondentijdstempel in base36 (~8 tekens)
001ateller4-teken base36-teller — voorkomt botsingen in dezelfde milliseconde
g2hsvingerafdruk4-teken base36 hostvingerafdruk (browser/omgevingsinfo)
3k7f9m2qwillekeurig8-teken base36 willekeurig blok — twee 32-bit waarden

De segmenten worden eenvoudig aaneengeschakeld — er zijn geen scheidingstekens. De totale lengte varieert enigszins afhankelijk van de huidige tijdstempelwaarde, maar blijft op ongeveer 25 tekens.

Hoe CUID Botsingen Voorkomt

Botsingsresistentie komt voort uit het stapelen van onafhankelijke entropiebronnen, zodat zelfs in slechtste gevallen (duizenden ID's per milliseconde op veel machines) de kans op twee identieke ID's verwaarloosbaar klein blijft.

Millisecondentijdstempel
Het eerste segment codeert de huidige tijd in base36. ID's die op verschillende momenten worden gegenereerd, sorteren automatisch lexicografisch op aanmaaktijd — handig voor paginering en foutopsporing.
Monotone Teller
Binnen hetzelfde proces wordt de 4-teken teller verhoogd bij elk gegenereerd ID. Zelfs als twee aanroepen in dezelfde milliseconde op dezelfde machine plaatsvinden, garandeert de teller uniciteit voor maximaal 65.536 ID's per milliseconde.
Machinevingerafdruk
Een hash afgeleid van omgevingsspecifieke gegevens (proces-ID + hostnaam in Node.js; schermafmetingen + navigator-info in de browser). Dit onderscheidt ID's gegenereerd op afzonderlijke hosts op exact dezelfde milliseconde met dezelfde tellerwaarde.
Willekeurig Blok
De laatste 8 tekens komen van twee onafhankelijke 32-bit willekeurige waarden gecodeerd in base36. Dit voegt een laatste laag entropie toe die beschermt tegen botsingen, zelfs als de vingerafdruk van twee machines toevallig tot dezelfde waarde hasht.

CUID vs UUID v4

Zowel CUID als UUID v4 worden veel gebruikt voor ID-generatie aan de clientzijde. Ze hanteren verschillende benaderingen voor hetzelfde probleem:

KenmerkCUID v1UUID v4
Formaatc + base36 (~25 tekens)hex-groepen (36 tekens met koppeltekens)
SorteerbaarRuwweg (tijdstempelprefix)Nee
URL-veiligJa (alleen alfanumeriek)Grotendeels (koppeltekens zijn geldig in URL's)
BotsingsresistentieHoog — tijdstempel + teller + vingerafdruk + willekeurigHoog — 122 bits willekeurig
VoorspelbaarheidGedeeltelijk (tijdstempel zichtbaar)Geen (puur willekeurig)
Lengte~25 tekens36 tekens
Vereist coördinatieNeeNee

UUID v4 is de veiligere keuze voor beveiligingsgevoelige scenario's omdat het geen tijdinformatie onthult. CUID heeft een voordeel wanneer u ID's wilt die ruwweg sorteerbaar, korter en vrij van koppeltekens zijn — handig voor gebruik in URL's, bestandsnamen of logs waar u snel wilt identificeren wanneer een record is aangemaakt.

CUID v1 vs CUID2

De CUID-specificatie is aanzienlijk herzien. Het begrijpen van de verschillen helpt u de juiste versie voor uw project te kiezen:

AspectCUID v1CUID v2
AlgoritmeDeterministische componentenSHA-3 gebaseerd, volledig ondoorzichtig
CryptografischNeeJa
Tijdstempel zichtbaarJaNee
FormaatBegint met "c"Begint met "c" (configureerbaar)
npm-pakket@paralleldrive/cuid (verouderd)@paralleldrive/cuid2
Lengte~25 tekens24 tekens (standaard, configureerbaar)

Voor nieuwe projecten is CUID v2 de aanbevolen keuze. De SHA-3-gebaseerde constructie betekent dat de uitvoer ondoorzichtig is — geen tijdstempel, teller of vingerafdruk kan worden teruggewerkt uit het ID. Gebruik CUID v1 alleen wanneer u achterwaartse compatibiliteit met een bestaande dataset nodig heeft of een implementatie zonder afhankelijkheden wilt.

Gebruiksscenario's

Gedistribueerde Databases
Meerdere databaseshards of microservices kunnen elk onafhankelijk primaire sleutels genereren zonder een sequentietabel of centrale ID-service, waardoor een enkel storingspunt wordt geëlimineerd.
ID-generatie aan Clientzijde
Een browser kan een CUID toewijzen aan een nieuw record voordat het naar de server wordt verzonden, waardoor optimistische UI-updates mogelijk zijn en de heen-en-terugreis om een server-toegewezen ID op te halen wordt geëlimineerd.
Offline-First Apps
Mobiele of PWA-apps die werken zonder connectiviteit kunnen records maken met stabiele ID's die synchronisatie overleven — geen conflicten wanneer het apparaat weer online gaat.
URL-slugs
CUID's bevatten alleen alfanumerieke tekens, waardoor ze veilig direct in URL-paden kunnen worden ingesloten zonder procentcodering. Het tijdstempelprefix voegt een ruwe aanmaaktijdvolgorde toe.
Gebeurtenis- / Logcorrelatie
Omdat het tijdstempel in het eerste segment is gecodeerd, kunnen logvermeldingen getagd met CUID's ruwweg worden gesorteerd op aanmaaktijd, zelfs over gedistribueerde logaggregators heen.
ORM / Prisma Standaard
Prisma gebruikt CUID als standaard @id-strategie voor String primaire sleutels — @default(cuid()) — waardoor het een van de meest gebruikte ID-formaten in het JavaScript-ecosysteem is.

Codevoorbeelden

Installeer het officiële CUID v2-pakket (aanbevolen) of schrijf een minimale v1-implementatie zonder afhankelijkheden:

JavaScript / TypeScript
// npm install @paralleldrive/cuid2  (recommended — CUID v2)
import { createId } from '@paralleldrive/cuid2'

const id = createId()
// → 'tz4a98xxat96iws9zmbrgj3a'

// Custom length
import { init } from '@paralleldrive/cuid2'
const createShortId = init({ length: 10 })
createShortId() // → 'zxp1l6mf4c'

Als u de voorkeur geeft aan een afhankelijkheidsvrije Node.js-implementatie van het v1-algoritme:

Node.js (no dependencies)
// Pure Node.js — CUID v1 style (no dependencies)
let counter = 0

function pad(str, size) {
  return str.padStart(size, '0').slice(-size)
}

function fingerprint() {
  const os = require('os')
  const source = [process.pid, os.hostname().length].join('')
  let hash = 0
  for (const c of source) {
    hash = ((hash << 5) - hash) + c.charCodeAt(0)
    hash |= 0
  }
  return pad(Math.abs(hash).toString(36), 4)
}

function cuid() {
  const timestamp = Date.now().toString(36)
  const cnt       = pad((counter++ & 0xffff).toString(36), 4)
  const fp        = fingerprint()
  const rnd       = pad(Math.floor(Math.random() * 0xffffffff).toString(36), 4)
              + pad(Math.floor(Math.random() * 0xffffffff).toString(36), 4)
  return 'c' + timestamp + cnt + fp + rnd
}

console.log(cuid()) // → 'clrc4gkwz001ag2hs3k7f9m2q'

CUID gebruiken als database primaire sleutel met Prisma en PostgreSQL:

Prisma / SQL
-- Use CUID as a primary key in PostgreSQL
CREATE TABLE users (
  id   TEXT        PRIMARY KEY DEFAULT gen_cuid(),
  name TEXT        NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Prisma schema (auto-generates CUID by default)
model User {
  id        String   @id @default(cuid())
  name      String
  createdAt DateTime @default(now())
}

Veelgestelde Vragen

Is CUID URL-veilig?
Ja. CUID v1 gebruikt alleen kleine letters en cijfers (base36-codering), die allemaal URL-veilige tekens zijn. Procentcodering is niet nodig bij het gebruik van een CUID in een URL-pad of queryparameter.
Is CUID cryptografisch veilig?
Nee. CUID v1 gebruikt Math.random() en onthult een zichtbaar tijdstempelprefix. Het is niet geschikt voor beveiligingsgevoelige doeleinden zoals sessietokens of wachtwoordherstellen links. Gebruik voor die gebruikssituaties crypto.randomUUID() of CUID v2.
CUID vs NanoID — welke moet ik kiezen?
NanoID is cryptografisch veilig, korter (standaard 21 tekens) en gebruikt een aanpasbaar alfabet. Kies NanoID wanneer beveiliging belangrijk is of wanneer u een korter ID nodig heeft. Kies CUID wanneer u een ruwweg sorteerbaar, tijdstempelvoorvoegsel-ID wilt dat menselijk debuggable is.
Moet ik CUID v1 of CUID v2 gebruiken?
CUID v2 is de huidige aanbeveling. Het is cryptografisch veilig, lekt geen tijdinformatie en wordt actief onderhouden. CUID v1 is handig wanneer u een eenvoudige implementatie zonder afhankelijkheden nodig heeft of een legacy systeem onderhoudt. Deze generator produceert CUID v1-ID's.
CUID vs ULID — wat is het verschil?
Beide hebben een tijdstempelprefix en zijn lexicografisch sorteerbaar. ULID gebruikt Crockford base32 (128 bits totaal, 48-bit tijdstempel + 80-bit willekeurig), waardoor het iets meer willekeurig is. CUID voegt een machinevingerafdruk en een monotone teller toe, wat de botsingsresistentie verbetert op dezelfde host binnen dezelfde milliseconde. ULID sorteert betrouwbaarder omdat het tijdstempel het volledige hogere deel beslaat.
Is CUID gegarandeerd uniek?
Geen enkel ID-schema kan een wiskundige garantie geven zonder een centrale coördinator. CUID maakt botsingen uiterst onwaarschijnlijk door vier onafhankelijke entropiebronnen te combineren: het tijdstempel, een per-procesteller, een machinevingerafdruk en willekeurige gegevens. In de praktijk zijn botsingen veel minder waarschijnlijk dan hardwarestoringen.