Generatore CUID

Genera ID unici resistenti alle collisioni (CUID v1)

Quantità

CUID generati

Clicca su Genera per creare CUID

CUID v1 è un formato legacy. Per i nuovi progetti, usa CUID2.

Cos'è CUID?

CUID (Collision-Resistant Unique Identifier) è un algoritmo open-source per generare ID univoci che funzionano bene nei sistemi distribuiti senza un coordinatore centrale. A differenza di un semplice UUID, un CUID è progettato per essere orizzontalmente scalabile — più server o schede del browser possono generare ID in modo indipendente con un rischio minimo di collisione.

Ogni CUID inizia con la lettera minuscola c, rendendo il formato immediatamente riconoscibile a colpo d'occhio. I caratteri rimanenti sono tutti alfanumerici minuscoli (base36), quindi un CUID è sicuro per gli URL e può essere utilizzato direttamente come segmento di percorso URL o chiave primaria del database senza codifica aggiuntiva.

La specifica CUID originale (v1) è stata creata da Eric Elliott e resa popolare tramite il pacchetto npm cuid. Ora è sostituita da CUID v2, che fornisce sicurezza crittografica. Questa pagina — e il generatore sopra — produce ID CUID v1, il formato classico ancora ampiamente presente nelle basi di codice di produzione.

Struttura di CUID

Un CUID v1 è lungo circa 25 caratteri ed è composto da cinque segmenti concatenati, ognuno dei quali porta un tipo diverso di entropia:

Esempio: clrc4gkwz001ag2hs3k7f9m2q
cprefissoSempre la lettera "c" — identifica un CUID
lrc4gkwztimestampTimestamp in millisecondi in base36 (~8 chars)
001acontatoreContatore base36 di 4 chars — previene collisioni nello stesso millisecondo
g2hsimpronta digitaleImpronta digitale dell'host base36 di 4 chars (info browser/ambiente)
3k7f9m2qcasualeBlocco casuale base36 di 8 chars — due valori a 32 bit

I segmenti sono semplicemente concatenati — non ci sono separatori. La lunghezza totale varia leggermente a seconda del valore attuale del timestamp, ma rimane di circa 25 caratteri.

Come CUID Previene le Collisioni

La resistenza alle collisioni deriva dalla stratificazione di fonti di entropia indipendenti in modo che anche negli scenari peggiori (migliaia di ID generati per millisecondo su molte macchine) la probabilità di due ID identici rimanga estremamente piccola.

Timestamp in Millisecondi
Il primo segmento codifica il tempo corrente in base36. Gli ID generati in momenti diversi si ordinano automaticamente lessicograficamente per tempo di creazione — utile per la paginazione e il debug.
Contatore Monotono
All'interno dello stesso processo, il contatore di 4 chars si incrementa ad ogni ID generato. Anche se due chiamate avvengono nello stesso millisecondo sulla stessa macchina, il contatore garantisce l'unicità per fino a 65.536 ID per millisecondo.
Impronta Digitale della Macchina
Un hash derivato da dati specifici dell'ambiente (ID processo + hostname in Node.js; dimensioni dello schermo + informazioni del navigator nel browser). Questo differenzia gli ID generati su host separati nello stesso millisecondo esatto con lo stesso valore del contatore.
Blocco Casuale
Gli ultimi 8 caratteri provengono da due valori casuali a 32 bit indipendenti codificati in base36. Questo aggiunge uno strato finale di entropia che protegge dalle collisioni anche se l'impronta digitale di due macchine produce lo stesso hash.

CUID vs UUID v4

Sia CUID che UUID v4 sono ampiamente usati per la generazione di ID lato client. Adottano approcci diversi allo stesso problema:

CaratteristicaCUID v1UUID v4
Formatoc + base36 (~25 chars)gruppi hex (36 chars con trattini)
OrdinabileApprossimativamente (prefisso timestamp)No
Sicuro per URLSì (solo alfanumerico)Principalmente (i trattini sono validi negli URL)
Resistenza alle collisioniAlta — timestamp + contatore + impronta + casualeAlta — 122 bit casuali
PrevedibilitàParzialmente (timestamp visibile)Nessuna (puramente casuale)
Lunghezza~25 caratteri36 caratteri
Richiede coordinamentoNoNo

UUID v4 è la scelta più sicura per scenari sensibili alla sicurezza perché non rivela informazioni temporali. CUID ha il vantaggio quando si vogliono ID vagamente ordinabili, più corti e privi di trattini — utile per l'uso in URL, nomi di file o log dove si vuole identificare rapidamente quando è stato creato un record.

CUID v1 vs CUID2

La specifica CUID è stata rivista in modo significativo. Capire le differenze aiuta a scegliere la versione giusta per il proprio progetto:

AspettoCUID v1CUID v2
AlgoritmoComponenti deterministiciBasato su SHA-3, completamente opaco
CrittograficoNo
Timestamp visibileNo
FormatoInizia con "c"Inizia con "c" (configurabile)
Pacchetto npm@paralleldrive/cuid (deprecato)@paralleldrive/cuid2
Lunghezza~25 chars24 chars (default, configurabile)

Per i nuovi progetti, CUID v2 è la scelta raccomandata. La sua costruzione basata su SHA-3 significa che l'output è opaco — nessun timestamp, contatore o impronta digitale può essere ricavato per ingegneria inversa dall'ID. Usa CUID v1 solo quando hai bisogno di compatibilità con un set di dati esistente o vuoi un'implementazione senza dipendenze.

Casi d'Uso

Database Distribuiti
Più shard di database o microservizi possono generare chiavi primarie indipendentemente senza una tabella di sequenze o un servizio ID centrale, eliminando un singolo punto di errore.
Generazione di ID Lato Client
Un browser può assegnare un CUID a un nuovo record prima di inviarlo al server, abilitando aggiornamenti ottimistici dell'interfaccia utente ed eliminando il round-trip necessario per ottenere un ID assegnato dal server.
App Offline-First
Le app mobili o PWA che funzionano senza connettività possono creare record con ID stabili che sopravvivono alla sincronizzazione — nessun conflitto quando il dispositivo torna online.
Slug URL
I CUID contengono solo caratteri alfanumerici, rendendoli sicuri da incorporare direttamente nei percorsi URL senza codifica percentuale. Il prefisso timestamp aggiunge un ordinamento approssimativo per tempo di creazione.
Correlazione di Eventi / Log
Poiché il timestamp è codificato nel primo segmento, le voci di log contrassegnate con CUID possono essere ordinate approssimativamente per tempo di creazione anche attraverso aggregatori di log distribuiti.
ORM / Default di Prisma
Prisma usa CUID come strategia @id predefinita per le chiavi primarie String — @default(cuid()) — rendendolo uno dei formati ID più ampiamente distribuiti nell'ecosistema JavaScript.

Esempi di Codice

Installa il pacchetto ufficiale CUID v2 (raccomandato) o scrivi un'implementazione minima di v1 senza dipendenze:

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'

Se preferisci un'implementazione Node.js senza dipendenze dell'algoritmo v1:

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'

Usare CUID come chiave primaria del database con Prisma e 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())
}

Domande Frequenti

CUID è sicuro per gli URL?
Sì. CUID v1 usa solo lettere minuscole e cifre (codifica base36), che sono tutti caratteri sicuri per URL. Non è necessaria la codifica percentuale quando si usa un CUID in un percorso URL o parametro di query.
CUID è crittograficamente sicuro?
No. CUID v1 usa Math.random() ed espone un prefisso timestamp visibile. Non è adatto per scopi sensibili alla sicurezza come token di sessione o link di reset password. Per questi casi d'uso, usa crypto.randomUUID() o CUID v2.
CUID vs NanoID — quale scegliere?
NanoID è crittograficamente sicuro, più corto (21 chars per default) e usa un alfabeto personalizzabile. Scegli NanoID quando la sicurezza è importante o quando hai bisogno di un ID più corto. Scegli CUID quando vuoi un ID approssimativamente ordinabile con prefisso timestamp che sia debuggabile da umani.
Devo usare CUID v1 o CUID v2?
CUID v2 è la raccomandazione attuale. È crittograficamente sicuro, non rivela informazioni temporali ed è attivamente mantenuto. CUID v1 è utile quando hai bisogno di un'implementazione semplice senza dipendenze o stai mantenendo un sistema legacy. Questo generatore produce ID CUID v1.
CUID vs ULID — qual è la differenza?
Entrambi hanno il prefisso timestamp e sono ordinabili lessicograficamente. ULID usa Crockford base32 (128 bit totali, 48 bit timestamp + 80 bit casuali), rendendolo leggermente più casuale. CUID aggiunge un'impronta digitale della macchina e un contatore monotono, che migliora la resistenza alle collisioni sullo stesso host nello stesso millisecondo. ULID ordina in modo più affidabile perché il timestamp occupa l'intera porzione di ordine superiore.
CUID garantisce l'unicità?
Nessuno schema di ID può dare una garanzia matematica senza un coordinatore centrale. CUID rende le collisioni estremamente improbabili combinando quattro fonti di entropia indipendenti: il timestamp, un contatore per processo, un'impronta digitale della macchina e dati casuali. In pratica, le collisioni sono molto meno probabili di un guasto hardware.