ToolDeck

CUID Generator

Generate collision-resistant unique IDs (CUID v1)

Count

Generated CUIDs

Click Generate to create CUIDs

CUID v1 is a legacy format. For new projects, use CUID2.

Vad är CUID?

CUID (Collision-Resistant Unique Identifier) är en öppen algoritm för att generera unika ID:n som fungerar väl i distribuerade system utan en central koordinator. Till skillnad från ett enkelt UUID är CUID utformat för att vara horisontellt skalbart — flera servrar eller webbläsarflikar kan generera ID:n oberoende av varandra med minimal kollisionsrisk.

Varje CUID börjar med den gemena bokstaven c, vilket gör formatet omedelbart igenkännbart. Återstående tecken är gemena alfanumeriska (base36), vilket innebär att ett CUID är URL-säkert och kan användas direkt som URL-sökvägssegment eller databasprimärnyckel utan extra kodning.

Den ursprungliga CUID-specifikationen (v1) skapades av Eric Elliott och populariserades via npm-paketet cuid. Den har nu ersatts av CUID v2, som erbjuder kryptografisk säkerhet. Denna sida — och generatorn ovan — producerar CUID v1-ID:n, det klassiska formatet som fortfarande är vanligt i produktionskodbaserna.

CUID-struktur

Ett CUID v1 är ungefär 25 tecken långt och består av fem sammansatta segment, där varje segment bär en annan typ av entropi:

Exempel: clrc4gkwz001ag2hs3k7f9m2q
cprefixAlltid bokstaven "c" — markerar ett CUID
lrc4gkwztidsstämpelMillisekundstidsstämpel i base36 (~8 tecken)
001aräknare4-teckens base36-räknare — förhindrar kollisioner inom samma millisekund
g2hsfingeravtryck4-teckens base36-värdfingeravtryck (webbläsar-/miljöinformation)
3k7f9m2qslumpmässig8-teckens base36-slumpblock — två 32-bitarsvärden

Segmenten är helt enkelt sammansatta — det finns inga avskiljare. Den totala längden varierar något beroende på det aktuella tidsstämpelvärdet men håller sig på ungefär 25 tecken.

Hur CUID förhindrar kollisioner

Kollisionsresistens uppnås genom att kombinera oberoende entropikällor, så att även i värsta fall (tusentals ID:n genererade per millisekund över många maskiner) förblir sannolikheten för två identiska ID:n försvinnande liten.

Millisekundstidsstämpel
Det första segmentet kodar den aktuella tiden i base36. ID:n som genereras vid olika tillfällen sorterar automatiskt lexikografiskt efter skapelsetid — användbart för paginering och felsökning.
Monoton räknare
Inom samma process ökar den 4-teckens räknaren med varje genererat ID. Även om två anrop sker under samma millisekund på samma maskin, garanterar räknaren unikhet för upp till 65 536 ID:n per millisekund.
Maskinfingeravtryck
En hash härledd från miljöspecifik data (process-ID + värdnamn i Node.js; skärmdimensioner + navigator-information i webbläsaren). Detta differentierar ID:n som genereras på separata värdar vid exakt samma millisekund med samma räknarvärde.
Slumpblock
De sista 8 tecknen kommer från två oberoende 32-bitars slumpvärden kodade i base36. Detta lägger till ett sista entropilager som skyddar mot kollisioner även om fingeravtrycket från två maskiner råkar hasha till samma värde.

CUID vs UUID v4

Både CUID och UUID v4 hanterar ID-generering på klientsidan utan en central server, men de gör olika avvägningar:

FunktionCUID v1UUID v4
Formatc + base36 (~25 tecken)hexgrupper (36 tecken med bindestreck)
SorterbarUngefär (tidsstämpelprefix)Nej
URL-säkerJa (endast alfanumeriska)Mestadels (bindestreck är ok i URL:er)
KollisionsresistensHög — tidsstämpel + räknare + fingeravtryck + slumpHög — 122 bitar slump
FörutsägbarhetDelvis (tidsstämpel synlig)Ingen (ren slump)
Längd~25 tecken36 tecken
Kräver koordineringNejNej

UUID v4 är det säkrare valet för säkerhetskänsliga scenarion eftersom det inte avslöjar någon tidinformation. CUID har fördelen när du vill ha ID:n som är ungefär sorterbara, kortare och saknar bindestreck — praktiskt i URL:er, filnamn eller loggar där du snabbt vill identifiera när en post skapades.

CUID v1 vs CUID2

CUID-specifikationen har reviderats betydligt. Så här jämför de två versionerna:

EgenskapCUID v1CUID v2
AlgoritmDeterministiska komponenterSHA-3-baserad, helt ogenomskinlig
KryptografiskNejJa
Tidsstämpel synligJaNej
FormatBörjar med "c"Börjar med "c" (konfigurerbar)
npm-paket@paralleldrive/cuid (avvecklad)@paralleldrive/cuid2
Längd~25 tecken24 tecken (standard, konfigurerbar)

För nya projekt är CUID v2 det rekommenderade valet. Dess SHA-3-baserade konstruktion innebär att utdata är ogenomskinliga — ingen tidsstämpel, räknare eller fingeravtryck kan bakåtkonstrueras från ID:t. Använd CUID v1 bara när du behöver bakåtkompatibilitet med en befintlig datamängd eller vill ha en beroendefri implementation.

Användningsfall

Distribuerade databaser
Flera databasshard eller mikrotjänster kan generera primärnycklar oberoende av varandra utan en sekvenstabell eller central ID-tjänst, vilket eliminerar en enda felpunkt.
ID-generering på klientsidan
En webbläsare kan tilldela ett CUID till en ny post innan den skickas till servern, vilket möjliggör optimistiska UI-uppdateringar och eliminerar rundresan som krävs för att hämta ett serverdefinierat ID.
Offline-först-appar
Mobil- eller PWA-appar som fungerar utan anslutning kan skapa poster med stabila ID:n som överlever synkronisering — inga konflikter uppstår när enheten kopplas upp igen.
URL-segment
CUIDs innehåller bara alfanumeriska tecken, vilket gör dem säkra att bädda in direkt i URL-sökvägar utan procentkodning. Tidsstämpelprefixet ger en grov ordning efter skapelsetid.
Händelse- och loggkorrelation
Eftersom tidsstämpeln är kodad i det första segmentet kan loggposter märkta med CUIDs grovt sorteras efter skapelsetid, även över distribuerade logginsamlare.
ORM/Prisma-standard
Prisma använder CUID som standardstrategi för @id på String-primärnycklar via @default(cuid()), vilket gör det till ett av de mest spridda ID-formaten i JavaScript-ekosystemet.

Kodexempel

Installera det officiella CUID v2-paketet (rekommenderat) eller skriv en minimal v1-implementation utan beroenden:

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'

Om du föredrar en beroendefri Node.js-implementation av v1-algoritmen:

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'

Använda CUID som databasprimärnyckel med Prisma och 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())
}

Vanliga frågor

Är CUID URL-säkert?
Ja. CUID v1 använder bara gemena bokstäver och siffror (base36-kodning), vilket är URL-säkra tecken. Ingen procentkodning behövs när man använder ett CUID i en URL-sökväg eller frågeparameter.
Är CUID kryptografiskt säkert?
Nej. CUID v1 använder Math.random() och exponerar ett synligt tidsstämpelprefix. Det lämpar sig inte för säkerhetskänsliga ändamål som sessionstoken eller lösenordsåterställningslänkar. Använd crypto.randomUUID() eller CUID v2 för sådana fall.
CUID vs NanoID — vilket ska jag välja?
NanoID är kryptografiskt säkert, kortare (21 tecken som standard) och använder ett anpassningsbart alfabet. Välj NanoID när säkerhet är viktigt eller när du behöver kortare ID:n. Välj CUID när du vill ha ett ungefär sorterbart, tidsstämpelprefixat ID som är lätt att felsöka.
Ska jag använda CUID v1 eller CUID v2?
CUID v2 är den aktuella rekommendationen. Det är kryptografiskt säkert, läcker inte tidinformation och underhålls aktivt. CUID v1 är användbart när du behöver en enkel beroendefri implementation eller underhåller ett äldre system. Denna generator producerar CUID v1-ID:n.
CUID vs ULID — vad är skillnaden?
Båda har tidsstämpelprefix och är lexikografiskt sorterbara. ULID använder Crockford base32 (128 bitar totalt, 48-bitars tidsstämpel + 80-bitars slump), vilket ger något mer slumpentropi. CUID lägger till ett maskinfingeravtryck och en monoton räknare, vilket förbättrar kollisionsresistensen på samma värd inom samma millisekund. ULID sorterar mer tillförlitligt eftersom tidsstämpeln upptar hela den höga delen.
Är CUID garanterat unikt?
Inget ID-schema kan ge en matematisk garanti utan en central koordinator. CUID gör kollisioner extremt osannolika genom att kombinera fyra oberoende entropikällor: tidsstämpeln, en per-process-räknare, ett maskinfingeravtryck och slumpdata. I praktiken är kollisioner långt mindre sannolika än hårdvarufel.