Generador CUID

Genera IDs únicos resistentes a colisiones (CUID v1)

Cantidad

CUIDs generados

Haz clic en Generar para crear CUIDs

CUID v1 es un formato heredado. Para nuevos proyectos, usa CUID2.

¿Qué es CUID?

CUID (Identificador Único Resistente a Colisiones) es un algoritmo de código abierto para generar IDs únicos que funcionan bien en sistemas distribuidos sin un coordinador central. A diferencia de un UUID simple, un CUID está diseñado para ser horizontalmente escalable — múltiples servidores o pestañas del navegador pueden generar IDs de forma independiente con un riesgo mínimo de colisión.

Todo CUID comienza con la letra minúscula c, haciendo que el formato sea inmediatamente reconocible de un vistazo. Los caracteres restantes son todos alfanuméricos en minúsculas (base36), por lo que un CUID es seguro para URLs y puede usarse directamente como segmento de ruta URL o clave primaria de base de datos sin codificación adicional.

La especificación original de CUID (v1) fue creada por Eric Elliott y popularizada a través del paquete npm cuid. Ahora está reemplazada por CUID v2, que proporciona seguridad criptográfica. Esta página — y el generador anterior — produce IDs CUID v1, el formato clásico que aún se encuentra ampliamente en bases de código en producción.

Estructura de CUID

Un CUID v1 tiene aproximadamente 25 caracteres de longitud y está compuesto de cinco segmentos concatenados, cada uno con un tipo diferente de entropía:

Ejemplo: clrc4gkwz001ag2hs3k7f9m2q
cprefijoSiempre la letra "c" — identifica un CUID
lrc4gkwzmarca de tiempoMarca de tiempo en milisegundos en base36 (~8 chars)
001acontadorContador base36 de 4 chars — previene colisiones en el mismo milisegundo
g2hshuella digitalHuella digital del host base36 de 4 chars (info del navegador/entorno)
3k7f9m2qaleatorioBloque aleatorio base36 de 8 chars — dos valores de 32 bits

Los segmentos simplemente se concatenan — no hay separadores. La longitud total varía ligeramente según el valor de la marca de tiempo actual, pero se mantiene en aproximadamente 25 caracteres.

Cómo CUID Previene Colisiones

La resistencia a colisiones proviene de superponer fuentes independientes de entropía de modo que incluso en escenarios de peor caso (miles de IDs generados por milisegundo en muchas máquinas) la probabilidad de dos IDs idénticos permanezca extremadamente pequeña.

Marca de Tiempo en Milisegundos
El primer segmento codifica el tiempo actual en base36. Los IDs generados en diferentes momentos se ordenan automáticamente lexicográficamente por tiempo de creación — útil para paginación y depuración.
Contador Monótono
Dentro del mismo proceso, el contador de 4 chars se incrementa con cada ID generado. Incluso si dos llamadas ocurren en el mismo milisegundo en la misma máquina, el contador garantiza unicidad para hasta 65.536 IDs por milisegundo.
Huella Digital de Máquina
Un hash derivado de datos específicos del entorno (ID de proceso + nombre de host en Node.js; dimensiones de pantalla + información del navegador en el navegador). Esto diferencia los IDs generados en hosts separados en el mismo milisegundo exacto con el mismo valor de contador.
Bloque Aleatorio
Los 8 caracteres finales provienen de dos valores aleatorios de 32 bits independientes codificados en base36. Esto añade una capa final de entropía que protege contra colisiones incluso si la huella digital de dos máquinas resulta en el mismo valor.

CUID vs UUID v4

Tanto CUID como UUID v4 son ampliamente usados para la generación de IDs del lado del cliente. Toman diferentes enfoques al mismo problema:

CaracterísticaCUID v1UUID v4
Formatoc + base36 (~25 chars)grupos hex (36 chars con guiones)
OrdenableAproximadamente (prefijo de timestamp)No
Seguro para URLSí (solo alfanumérico)Mayormente (los guiones son válidos en URLs)
Resistencia a colisionesAlta — timestamp + contador + huella + aleatorioAlta — 122 bits aleatorios
PredecibilidadParcialmente (timestamp visible)Ninguna (puramente aleatorio)
Longitud~25 caracteres36 caracteres
Requiere coordinaciónNoNo

UUID v4 es la opción más segura para escenarios sensibles a la seguridad porque no revela información de tiempo. CUID tiene ventaja cuando quieres IDs vagamente ordenables, más cortos y sin guiones — útil para uso en URLs, nombres de archivo o registros donde deseas identificar rápidamente cuándo se creó un registro.

CUID v1 vs CUID2

La especificación CUID ha sido revisada significativamente. Entender las diferencias te ayuda a elegir la versión correcta para tu proyecto:

AspectoCUID v1CUID v2
AlgoritmoComponentes deterministasBasado en SHA-3, completamente opaco
CriptográficoNo
Timestamp visibleNo
FormatoComienza con "c"Comienza con "c" (configurable)
Paquete npm@paralleldrive/cuid (obsoleto)@paralleldrive/cuid2
Longitud~25 chars24 chars (por defecto, configurable)

Para nuevos proyectos, CUID v2 es la opción recomendada. Su construcción basada en SHA-3 hace que la salida sea opaca — no se puede hacer ingeniería inversa del timestamp, contador o huella digital desde el ID. Usa CUID v1 solo cuando necesites compatibilidad hacia atrás con un conjunto de datos existente o quieras una implementación sin dependencias.

Casos de Uso

Bases de Datos Distribuidas
Múltiples shards de base de datos o microservicios pueden generar claves primarias de forma independiente sin una tabla de secuencias o servicio central de IDs, eliminando un único punto de fallo.
Generación de ID del Lado del Cliente
Un navegador puede asignar un CUID a un nuevo registro antes de enviarlo al servidor, habilitando actualizaciones optimistas de UI y eliminando el viaje de ida y vuelta necesario para obtener un ID asignado por el servidor.
Apps Offline-First
Las apps móviles o PWA que operan sin conectividad pueden crear registros con IDs estables que sobreviven la sincronización — sin conflictos cuando el dispositivo vuelve a conectarse.
Slugs de URL
Los CUIDs contienen solo caracteres alfanuméricos, haciéndolos seguros para incrustar directamente en rutas URL sin codificación porcentual. El prefijo de timestamp añade un orden aproximado por tiempo de creación.
Correlación de Eventos / Registros
Dado que el timestamp está codificado en el primer segmento, las entradas de registro etiquetadas con CUIDs pueden ordenarse aproximadamente por tiempo de creación incluso a través de agregadores de registros distribuidos.
ORM / Predeterminado de Prisma
Prisma usa CUID como su estrategia predeterminada @id para claves primarias String — @default(cuid()) — haciéndolo uno de los formatos de ID más ampliamente desplegados en el ecosistema JavaScript.

Ejemplos de Código

Instala el paquete oficial CUID v2 (recomendado) o escribe una implementación mínima de v1 sin dependencias:

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'

Si prefieres una implementación Node.js sin dependencias del 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'

Usando CUID como clave primaria de base de datos con Prisma y 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())
}

Preguntas Frecuentes

¿Es CUID seguro para URLs?
Sí. CUID v1 usa solo letras minúsculas y dígitos (codificación base36), que son todos caracteres seguros para URLs. No se necesita codificación porcentual al usar un CUID en una ruta URL o parámetro de consulta.
¿Es CUID criptográficamente seguro?
No. CUID v1 usa Math.random() y expone un prefijo de timestamp visible. No es adecuado para propósitos sensibles a la seguridad como tokens de sesión o enlaces de restablecimiento de contraseña. Para esos casos de uso, usa crypto.randomUUID() o CUID v2.
CUID vs NanoID — ¿cuál debo elegir?
NanoID es criptográficamente seguro, más corto (21 chars por defecto) y usa un alfabeto personalizable. Elige NanoID cuando la seguridad importa o cuando necesitas un ID más corto. Elige CUID cuando quieras un ID aproximadamente ordenable con prefijo de timestamp que sea depurable por humanos.
¿Debo usar CUID v1 o CUID v2?
CUID v2 es la recomendación actual. Es criptográficamente seguro, no filtra información de tiempo y está activamente mantenido. CUID v1 es útil cuando necesitas una implementación simple sin dependencias o estás manteniendo un sistema heredado. Este generador produce IDs CUID v1.
CUID vs ULID — ¿cuál es la diferencia?
Ambos tienen prefijo de timestamp y son ordenables lexicográficamente. ULID usa Crockford base32 (128 bits en total, 48 bits de timestamp + 80 bits aleatorios), haciéndolo ligeramente más aleatorio. CUID añade una huella digital de máquina y un contador monótono, lo que mejora la resistencia a colisiones en el mismo host dentro del mismo milisegundo. ULID ordena de forma más confiable porque el timestamp ocupa la porción de orden superior completa.
¿Está garantizado que CUID sea único?
Ningún esquema de ID puede dar una garantía matemática sin un coordinador central. CUID hace que las colisiones sean extremadamente improbables combinando cuatro fuentes independientes de entropía: el timestamp, un contador por proceso, una huella digital de máquina y datos aleatorios. En la práctica, las colisiones son mucho menos probables que un fallo de hardware.