Primer plano de una pantalla de terminal mostrando cadenas de identificadores UUID hexadecimales sobre fondo oscuro

Qué es un UUID y en qué se diferencian sus versiones (v1-v8)

· ⏱ 9+ min lectura
Tecnología Desarrollo Web #identificadores-unicos #bases-de-datos #backend #desarrollo-web #arquitectura-software #sistemas-distribuidos

Casi todo el mundo que ha tocado una base de datos sabe lo que es un UUID: una ristra de letras y números que parece aleatoria y sirve para que dos registros nunca compartan identificador. Hasta ahí, bien.

Lo que ya no sabe casi nadie es que existen ocho versiones distintas de UUID, que no son intercambiables entre sí, y que elegir la que no toca te pasa factura de verdad cuando tu tabla lleva millones de filas y el índice empieza a arrastrar. Vayamos por partes.

Qué es un UUID, exactamente

UUID son las siglas de Universally Unique Identifier, identificador único universal. Es un número de 128 bits que, escrito en hexadecimal, se representa como 32 caracteres divididos en cinco grupos:

550e8400-e29b-41d4-a716-446655440000

La gracia no está en el formato, está en el problema que resuelve. Un ID autoincremental de base de datos (1, 2, 3, 4…) necesita una única fuente de verdad que lleve la cuenta: una secuencia, un contador central. Eso funciona de maravilla con una base de datos y un servidor. En cuanto tienes varios servicios, varias bases de datos o varios clientes generando identificadores a la vez y sin hablar entre ellos, el contador central se convierte en un cuello de botella o, directamente, en un generador de colisiones.

Un UUID resuelve eso sin coordinación. Cualquier proceso, en cualquier máquina, puede generar uno y la probabilidad de que choque con otro ya existente es, a efectos prácticos, cero. Por eso están por todas partes: claves primarias, identificadores de sesión, nombres de archivo, trazas de peticiones distribuidas.

De dónde sale el estándar: RFC 4122 y su sucesor, RFC 9562

El formato UUID no lo inventó una empresa concreta, lo define un estándar. Durante casi veinte años, la referencia fue la RFC 4122, publicada en 2005, que definía las versiones de la 1 a la 5.

En 2024 llegó su sustituto: la RFC 9562. No rompe nada de lo anterior (las versiones 1 a 5 siguen funcionando exactamente igual), pero añade tres versiones nuevas, la 6, la 7 y la 8, pensadas para los problemas que el UUID original no resolvía bien: ordenación y privacidad. También formaliza dos valores especiales, el UUID nil (los 128 bits a cero, usado para representar “ningún UUID”) y el UUID max (los 128 bits a uno, usado como marcador de límite superior).

Las ocho versiones, una por una

Aquí está el lío que casi nadie tiene claro. Cada versión resuelve un problema distinto, y no todas están vivas hoy.

  • v1 (tiempo + MAC): combina un timestamp de 60 bits con la dirección MAC de la máquina que lo genera. Es ordenable por fecha, pero filtra la MAC del equipo que lo creó, algo que la propia RFC 9562 señala como riesgo de privacidad. Está en desuso para proyectos nuevos.
  • v2 (DCE Security): pensado para incrustar identificadores de usuario y grupo de sistemas POSIX. Casi nadie lo implementa. Considérala oficialmente muerta.
  • v3 (nombre + MD5): genera un UUID determinista a partir de un namespace y un nombre, usando MD5. Determinista significa que el mismo nombre siempre da el mismo UUID, útil para convertir URLs o strings en identificadores estables. El problema es que MD5 está criptográficamente roto.
  • v4 (aleatorio): el que casi todo el mundo se imagina cuando piensa en un UUID. 122 bits puramente aleatorios. Sin orden, sin lógica, solo entropía. La propia RFC 9562 recomienda usar v4 cuando el identificador tenga implicaciones de seguridad.
  • v5 (nombre + SHA-1): lo mismo que la v3 pero con SHA-1 en vez de MD5. La RFC 9562 dice literalmente que, cuando haya que elegir, v5 debería usarse en lugar de v3.
  • v6 (tiempo reordenado): coge los mismos datos que la v1 (timestamp y nodo) pero reordena los bits del timestamp de más a menos significativo, para que se puedan ordenar comparando los bytes directamente, sin tener que parsear nada. Corrige el problema de ordenación de la v1, pero mantiene el mismo riesgo de privacidad si se usa la MAC real.
  • v7 (tiempo + aleatorio, la moderna): pone un timestamp Unix en milisegundos en los primeros 48 bits y rellena el resto con datos aleatorios. El resultado: identificadores que se pueden ordenar cronológicamente por diseño, sin filtrar hardware ni depender de contadores centralizados. Es la que recomienda la propia RFC para casos nuevos donde el orden importa.
  • v8 (personalizada): la RFC solo fija los bits de versión y variante; los 122 bits restantes son de libre uso para quien implemente. Pensada para casos muy concretos donde una empresa quiere meter sus propios datos dentro de un UUID válido.

En la práctica, con que te quedes con cuatro (v1, v4, v5 y v7) vas sobrado. El resto son curiosidades históricas o casos de nicho.

Cuál usar en la práctica: v4 contra v7

Si no necesitas ordenar nada, usa v4 y no le des más vueltas. Es aleatorio, es simple, todos los lenguajes lo soportan de fábrica y no filtra ningún dato sobre quién o cuándo lo generó.

El problema de la v4 aparece cuando la usas como clave primaria en una tabla grande. Como es totalmente aleatoria, cada inserción nueva cae en un punto distinto del índice, y eso obliga a la base de datos a reordenar páginas del árbol B-tree constantemente. Con pocas filas no se nota. Con millones, el índice se fragmenta y el rendimiento de escritura se resiente.

Ahí es donde entra la v7: al llevar el timestamp por delante, cada UUID nuevo se genera mayor que el anterior, así que se inserta siempre al final del índice, igual que un ID autoincremental de toda la vida, pero sin necesitar un contador central. PostgreSQL 18 ya trae soporte nativo para generar UUIDs v7, algo que hasta hace poco había que montar a mano.

El soporte en el resto del ecosistema todavía va desigual. Node.js solo genera v4 con crypto.randomUUID(); para v7 hace falta tirar del paquete uuid (a partir de su versión 10) o de runtimes como Bun, que ya incluye Bun.randomUUIDv7() de serie.

Un aviso importante: un UUID no es un secreto

Aquí va algo que me cabrea cuando lo veo en producción: un UUID no es un token de seguridad. La propia RFC lo deja negro sobre blanco: los UUID no están pensados para ser difíciles de adivinar, y no deben usarse como si fueran una contraseña, un token de sesión o una capacidad de acceso.

Que un identificador tenga 128 bits no significa que sea impredecible. Una v1 o una v6 mal generadas filtran cuándo y desde qué máquina se crearon. Si necesitas algo realmente impredecible para autenticación, eso es un problema de criptografía, no de formato de identificador. Para eso están los tokens generados con un generador aleatorio criptográficamente seguro, no un UUID reutilizado como si lo fuera.

Lo que me llevo de todo esto

Un UUID nunca fue “solo un número aleatorio largo”. Es una familia de ocho formatos distintos, cada uno resolviendo un problema concreto: coordinación sin servidor central, determinismo a partir de un nombre, orden cronológico sin filtrar hardware. La mayoría de los problemas de rendimiento con UUID que he visto en bases de datos reales venían de usar v4 donde tocaba v7, no de un fallo del formato en sí.

Así que la próxima vez que tu ORM genere un identificador por defecto, merece la pena pararse un segundo y preguntar cuál está usando. No es lo mismo.

Preguntas frecuentes

¿Qué es un UUID?

Un UUID (Universally Unique Identifier) es un número de 128 bits, representado como 32 caracteres hexadecimales en cinco grupos, que sirve para identificar algo de forma única sin necesitar un contador central. Cualquier proceso puede generar uno con una probabilidad de colisión prácticamente nula.

¿Cuál es la diferencia entre UUID v4 y v7?

La v4 es totalmente aleatoria: no filtra información y no tiene ningún orden. La v7 lleva un timestamp en milisegundos en los primeros bits, lo que hace que los UUID generados más tarde sean siempre mayores que los anteriores. Eso mejora mucho el rendimiento cuando el UUID se usa como clave primaria en una tabla grande, porque las inserciones no fragmentan el índice.

¿Por qué la v1 y la v6 están en desuso para proyectos nuevos?

Porque incluyen la dirección MAC de la máquina que generó el identificador, lo que supone una filtración de privacidad: cualquiera con el UUID puede saber en qué hardware y en qué momento exacto se creó. La RFC 9562 señala explícitamente este riesgo y recomienda no usar direcciones MAC reales dentro de un UUID.

¿Puedo usar un UUID como token de sesión o de seguridad?

No deberías. Un UUID no está diseñado para ser impredecible en el sentido criptográfico, solo para no colisionar. La propia especificación advierte que los UUID no deben tratarse como capacidades de acceso ni como secretos. Para tokens de sesión o autenticación, usa un generador aleatorio criptográficamente seguro pensado para ese fin.

Fuentes

Compártelo si te ha resultado útil, sobre todo con quien siga usando v1 sin saber por qué.

¿Tú qué versión usas en tus proyectos, v4 de toda la vida o ya te has pasado a v7? Cuéntame.

Y… la próxima vez que tu framework genere un ID, ya sabes qué preguntarle.

Artículos relacionados

Pizarra con un grafo de nodos y aristas dibujado a mano junto a flechas de un diagrama de ordenación, sobre una mesa con un portátil

Algoritmos desde cero: del bubble sort a A*, toda la serie

Si la serie de Fundamentos te enseñó a escribir programas que funcionan, esta te va a enseñar a escribir programas que funcionan bien: rápidos, eficientes y capaces de aguantar montañas de datos sin ahogarse. Arranco la serie de Algoritmos, dieciséis entregas, los lunes, miércoles y viernes, para recorrer los algoritmos y estructuras de datos más famosos y útiles que existen, los que resuelven los problemas de verdad: buscar, ordenar, recorrer grafos, optimizar y trabajar con texto. Empezamos por la notación Big-O (medir si un programa escala o se ahoga) y terminamos en A*, el algoritmo que usan los videojuegos para encontrar caminos. Es lenguaje-agnóstico, con pseudocódigo y ejemplos. Este post es el índice y el calendario completo.

16:00 8 min Marcos Ramírez Lucía
Terminal de desarrollador con avisos de actualización de seguridad de Node.js y Java

No solo PHP: Node.js y Java también se parchean esta semana

La misma semana que PHP2Shell, Node.js corrigió diez vulnerabilidades, una de ellas en el descompresor Brotli que permite ejecutar código, y Oracle sacó su parche trimestral con más de 1.200 fallos, 55 de ellos en Java. Te resumo qué versiones de Node necesitas, por qué hay que reconstruir los snapshots y no solo actualizar, qué pasa con Node 20 y qué mirar en Java, para que no te quedes solo con el parche de PHP.

23:00 6 min Marcos Ramírez Lucía
Pantalla de un servidor con código PHP y un aviso rojo de vulnerabilidad crítica

PHP2Shell: los dos fallos críticos de PHP y cómo protegerte

PHP ha corregido dos fallos críticos que permiten ejecutar código en tu servidor sin iniciar sesión, y hay ataques desde antes de que saliera el parche. Te cuento qué son CVE-2026-109618 y CVE-2026-109619 sin tecnicismos, a quién afectan (Apache con mod_php, PHP-FPM, FrankenPHP...), qué versión necesitas en cada rama, cómo comprobar la tuya aunque estés en un hosting compartido y qué hacer si no puedes actualizar todavía.

08:30 7 min Marcos Ramírez Lucía