UUID explicado: estructura de 128 bits, versiones y casos de uso reales

Cada vez que te registras en un servicio, se crea un identificador único para tu cuenta. Cada solicitud de API lleva un ID de traza. Cada fila en una base de datos distribuida necesita una clave primaria que no colisione con claves generadas en otras máquinas. ¿La solución detrás de todo esto? UUID — Universally Unique Identifier (Identificador Universalmente Único).

Esta guía explica qué son los UUIDs, cómo están estructurados, qué hace cada versión bajo el capó y cuándo usarlos (o evitarlos).

UUID de un Vistazo

Un UUID es un identificador de 128 bits (16 bytes) diseñado para ser globalmente único sin requerir una autoridad central. Se escribe como 32 dígitos hexadecimales en el formato canónico 8-4-4-4-12:

550e8400-e29b-41d4-a716-446655440000
|------| |--| |--| |--| |----------|
 8 hex   4    4    4      12 hex

Eso son 32 caracteres hex + 4 guiones = 36 caracteres en total. Los guiones son puramente decorativos — no portan datos.

Datos clave:

128 bits = 2¹²⁸ ≈ 3,4 × 10³⁸ valores posibles
Estandarizado por RFC 9562 (mayo de 2024, reemplaza RFC 4122)
También llamado GUID (Globally Unique Identifier) en los ecosistemas de Microsoft — mismo formato, nombre diferente
Soportado de forma nativa por PostgreSQL (tipo uuid), MySQL (BINARY(16) o CHAR(36)) y prácticamente todos los lenguajes de programación

Anatomía de un UUID

Cada UUID codifica dos campos de metadatos en posiciones de bits fijas, independientemente de la versión:

550e8400-e29b-41d4-a716-446655440000
                  ^  ^
                  |  |
          Versión-┘  └-Variante

Campo de Versión (Bits 48-51)

El 13.º dígito hex (primer dígito del tercer grupo) identifica la versión del UUID:

Dígito Hex	Versión	Método
`1`	v1	Timestamp + dirección MAC
`3`	v3	Hash MD5 de espacio de nombres + nombre
`4`	v4	Criptográficamente aleatorio
`5`	v5	Hash SHA-1 de espacio de nombres + nombre
`6`	v6	Timestamp reordenado (RFC 9562)
`7`	v7	Timestamp Unix + aleatorio (RFC 9562)
`8`	v8	Personalizado / específico de implementación

Campo de Variante (Bits 64-65)

El 17.º dígito hex (primer dígito del cuarto grupo) identifica la variante. Para los UUIDs RFC 4122/9562, los primeros bits son 10, lo que significa que este dígito hex es siempre 8, 9, a o b.

Ejemplo Desglosado

550e8400-e29b-41d4-a716-446655440000
              ↑         ↑
              4 → v4    a → variante RFC 4122

Este es un UUID v4 (aleatorio), variante RFC 4122/9562.

Versiones de UUID Explicadas

Versión 1: Timestamp + Dirección MAC

UUID v1 fue el diseño original. Codifica:

Timestamp de 60 bits — intervalos de 100 nanosegundos desde el 15 de octubre de 1582 (la reforma del calendario gregoriano)
Secuencia de reloj de 14 bits — contador de monotonicidad para prevenir duplicados ante retrocesos del reloj
Nodo de 48 bits — típicamente la dirección MAC de la máquina

|        Timestamp         | Ver |  Clk  |Var|    Nodo (MAC)     |
| 60 bits                  | 4b  | 14b   |2b | 48 bits           |

Problemas:

Expone el tiempo de generación y la identidad del hardware (riesgo de privacidad)
Las direcciones MAC pueden falsificarse, comprometiendo la unicidad
La época de 1582 es confusa y requiere conversión

Veredicto: Obsoleto por RFC 9562. Usa v7 en su lugar para UUIDs basados en tiempo.

Versión 3: Basado en Nombre MD5 (Determinista)

UUID v3 aplica hash a un UUID de espacio de nombres y una cadena de nombre usando MD5. Las mismas entradas siempre producen el mismo UUID.

import uuid
# espacio de nombres = DNS, nombre = "example.com"
print(uuid.uuid3(uuid.NAMESPACE_DNS, "example.com"))
# → "9073926b-929f-31c2-abc9-fad77ae3e8eb"  (siempre este valor)

Se definen cuatro espacios de nombres estándar:

DNS: 6ba7b810-9dad-11d1-80b4-00c04fd430c8
URL: 6ba7b811-9dad-11d1-80b4-00c04fd430c8
OID: 6ba7b812-9dad-11d1-80b4-00c04fd430c8
X.500: 6ba7b814-9dad-11d1-80b4-00c04fd430c8

Veredicto: Funcional pero prefiere v5 — SHA-1 es más fuerte que MD5.

Versión 4: Aleatorio — El Más Popular

UUID v4 rellena 122 bits con datos aleatorios criptográficamente seguros (los 6 bits restantes están reservados para los campos de versión y variante).

|           Aleatorio       | Ver |    Aleatorio  |Var|    Aleatorio    |
| 48 bits                   | 4b  | 12 bits       |2b | 62 bits         |

Con 2¹²² ≈ 5,3 × 10³⁶ valores posibles, la probabilidad de colisión es astronómicamente baja. Para alcanzar una probabilidad del 50% de al menos una colisión, necesitarías aproximadamente 2,71 × 10¹⁸ UUIDs — eso es 2,71 trillones.

// Todos los navegadores modernos y Node.js lo soportan
const id = crypto.randomUUID();
console.log(id); // → "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d"

Ventajas: simple, privado, universalmente soportado, no requiere coordinación.

Desventaja: la distribución aleatoria causa fragmentación del índice B-tree cuando se usa como clave primaria de base de datos. Para casos de uso intensivos en base de datos, considera v7.

Versión 5: Basado en Nombre SHA-1 (Determinista)

Idéntico a v3 pero usa SHA-1 en lugar de MD5. Las mismas entradas siempre producen el mismo UUID.

import uuid
print(uuid.uuid5(uuid.NAMESPACE_DNS, "example.com"))
# → "cfbff0d1-9375-5685-968c-48ce8b15ae17"  (siempre este valor)

Casos de uso:

Generar IDs estables a partir de URLs o nombres DNS
Claves de almacenamiento con direccionamiento por contenido
Fixtures de prueba reproducibles

Importante: v3 y v5 NO están diseñados para seguridad. Son deterministas — cualquiera que conozca el espacio de nombres y el nombre puede reproducir el UUID.

Versión 7: Timestamp Unix + Aleatorio (Recomendado para Nuevos Proyectos)

UUID v7 es la versión más nueva, introducida en RFC 9562 (mayo de 2024). Codifica:

Timestamp Unix de 48 bits en milisegundos — monotónicamente creciente
74 bits de aleatoriedad criptográfica

|    Timestamp Unix (ms)    | Ver |  rand_a  |Var|     rand_b       |
| 48 bits                   | 4b  | 12 bits  |2b | 62 bits          |

Esto significa que los UUIDs v7 están naturalmente ordenados por tiempo de creación — los UUIDs más nuevos son siempre lexicográficamente mayores que los más antiguos. Esta propiedad los hace ideales para claves primarias de base de datos, donde los índices B-tree permanecen secuenciales en lugar de fragmentarse aleatoriamente.

import { v7 as uuidv7 } from "uuid";

const id1 = uuidv7(); // generado en T₁
const id2 = uuidv7(); // generado en T₂ (T₂ > T₁)
console.log(id1 < id2); // → true (comparación lexicográfica)

Por qué importa para las bases de datos: la propiedad secuencial de v7 reduce las divisiones de páginas de índice hasta un 90% en comparación con v4, resultando en inserciones más rápidas, índices más pequeños y mejor rendimiento de caché.

UUID vs GUID — ¿Cuál Es la Diferencia?

No hay diferencia funcional. GUID (Globally Unique Identifier) es el nombre de Microsoft para UUID, usado en Windows, .NET, COM y SQL Server. El formato es idéntico: 128 bits, hex 8-4-4-4-12.

La única diferencia cosmética: las herramientas de Microsoft a veces muestran los GUIDs en mayúsculas con llaves:

UUID: 550e8400-e29b-41d4-a716-446655440000
GUID: {550E8400-E29B-41D4-A716-446655440000}

Si alguien pregunta por la “diferencia entre UUID y GUID”, la respuesta es: branding.

Valores UUID Especiales

RFC 9562 define dos UUIDs especiales:

Nombre	Valor	Propósito
UUID Nil	`00000000-0000-0000-0000-000000000000`	Representa ausencia de valor (como `null`)
UUID Max	`ffffffff-ffff-ffff-ffff-ffffffffffff`	Marcador de límite o valor centinela

Nunca uses estos como identificadores reales — no son únicos por definición.

Probabilidad de Colisión: El Problema del Cumpleaños

El “problema del cumpleaños” calcula cuántos UUIDs necesitas antes de que una colisión sea probable. Para UUID v4 (122 bits aleatorios):

UUIDs Generados	Probabilidad de Colisión
1 millón	~10⁻²² (virtualmente imposible)
1 mil millones	~10⁻¹⁶ (aún insignificante)
2,71 × 10¹⁸	50% (el “límite del cumpleaños”)

Para ponerlo en contexto: si generaras 1 mil millones de UUIDs por segundo, tardarías 86 años en alcanzar una probabilidad del 50% de una sola colisión. En la práctica, los fallos de hardware, los errores de software y los rayos cósmicos son todos más propensos a causar un duplicado que las matemáticas de UUID v4.

La fórmula: p(n) ≈ n² / (2 × 2¹²²)

Cómo Validar un UUID

Un UUID válido cumple este patrón regex (sin distinción entre mayúsculas y minúsculas):

^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

Esto comprueba:

El formato hex 8-4-4-4-12
El dígito de versión es 1-7 (posición 15)
El nibble de variante comienza con 8, 9, a o b (posición 20)

function isValidUUID(str) {
  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str);
}

isValidUUID("550e8400-e29b-41d4-a716-446655440000"); // → true
isValidUUID("no-es-un-uuid"); // → false

Generando UUIDs en Cada Lenguaje

JavaScript / TypeScript

// Navegador y Node.js — v4 nativo
crypto.randomUUID();

// Paquete npm uuid — soporta v1, v3, v4, v5, v7
import { v4, v7 } from "uuid";
v4(); // aleatorio
v7(); // ordenado por tiempo

Python

import uuid

uuid.uuid4()                                    # aleatorio
uuid.uuid5(uuid.NAMESPACE_DNS, "example.com")   # determinista
# uuid.uuid7() planeado para Python 3.14+

Go

import "github.com/google/uuid"

uuid.New()              // v4 aleatorio
uuid.Must(uuid.NewV7()) // v7 ordenado por tiempo

Java

import java.util.UUID;

UUID.randomUUID();        // v4 aleatorio
// UUID v7: usa com.fasterxml.uuid o java.util.UUID en JDK 21+

SQL (PostgreSQL)

-- v4 (PostgreSQL 13+)
SELECT gen_random_uuid();

-- v7 (PostgreSQL 18+)
SELECT uuidv7();

Casos de Uso Comunes

Claves Primarias de Base de Datos

Los UUIDs te permiten generar IDs en cualquier lugar — en la aplicación, en el cliente, en el edge — sin un viaje de ida y vuelta a la base de datos. Esto permite arquitecturas offline-first y simplifica los sistemas distribuidos. Usa v7 para el mejor rendimiento del índice, o v4 si no te importa el orden.

Trazado de Solicitudes de API

Asigna un UUID a cada solicitud de API en el punto de entrada (gateway, balanceador de carga). Pásalo a través de todos los servicios downstream en una cabecera como X-Request-ID. Esto hace trivial correlacionar logs a través de microservicios.

Claves de Idempotencia

Las APIs usan UUIDs como claves de idempotencia para garantizar que las solicitudes reintentadas no creen recursos duplicados. El cliente genera un UUID antes del primer intento y envía el mismo UUID en los reintentos.

Identificadores de Sesión

Los UUIDs proporcionan suficiente unicidad para prevenir colisiones de sesión en grandes bases de usuarios. A diferencia de los enteros auto-incrementales, no pueden enumerarse — un atacante no puede adivinar IDs de sesión válidos incrementando un número.

Almacenamiento con Direccionamiento por Contenido

UUID v5 genera IDs deterministas a partir del contenido. Dada la misma entrada, siempre obtienes el mismo UUID — útil para deduplicación, caché y compilaciones reproducibles.

Consideraciones de Seguridad

Los UUIDs NO Son Tokens de Seguridad

Los UUIDs están diseñados para la unicidad, no para el secreto. Problemas clave:

UUID v1 expone el timestamp de generación y la dirección MAC
UUID v4 tiene 122 bits aleatorios pero una estructura predecible (los bits de versión/variante son fijos)
UUID v3/v5 son deterministas — cualquiera que conozca el espacio de nombres y el nombre puede reproducir el UUID

Para tokens de seguridad, claves API o secretos de sesión, usa un CSPRNG dedicado con 128 o más bits de aleatoriedad pura:

// Para tokens de seguridad — NO es un UUID, pero es completamente aleatorio
const token = Array.from(crypto.getRandomValues(new Uint8Array(32)))
  .map(b => b.toString(16).padStart(2, "0"))
  .join("");

UUID v7 Expone el Tiempo de Creación

Los primeros 48 bits de un UUID v7 codifican el timestamp de creación en milisegundos. Cualquiera que reciba un UUID v7 puede extraer cuándo fue creado:

const hex = "01906b5e-4a3e-7234-8f56-b8c12d4e5678".replace(/-/g, "").slice(0, 12);
new Date(parseInt(hex, 16));
// → 2024-07-01T12:34:56.000Z

Si el tiempo de creación es información sensible, usa v4 en su lugar.

No Uses UUIDs para Prevenir la Enumeración

Aunque los UUIDs son más difíciles de adivinar que los enteros secuenciales, no deberían ser tu único mecanismo de control de acceso. Siempre aplica comprobaciones de autorización — no dependas de la oscuridad de la URL.

Preguntas Frecuentes

¿Por qué tienen guiones los UUIDs?

Los guiones en el formato 8-4-4-4-12 son puramente para legibilidad humana. No portan datos y se ignoran durante el análisis. Algunos sistemas almacenan los UUIDs sin guiones (32 caracteres hex), lo cual es igualmente válido.

¿Pueden dos UUIDs ser iguales alguna vez?

Teóricamente sí, prácticamente no. Para UUID v4 con 122 bits aleatorios, la probabilidad de generar dos UUIDs idénticos es aproximadamente 1 en 5,3 × 10³⁶ para cualquier par dado. A tasas de generación del mundo real, es más probable que te alcance un rayo mientras ganas la lotería que encontrar una colisión de UUID.

¿Son los UUIDs secuenciales?

Solo algunas versiones. UUID v1, v6 y v7 contienen timestamps y se ordenan cronológicamente. UUID v4 es completamente aleatorio sin ningún orden. UUID v3 y v5 son deterministas pero no ordenados.

¿Cuánto almacenamiento usa un UUID?

Binario: 16 bytes (128 bits) — el almacenamiento más eficiente
Cadena (con guiones): 36 bytes (ASCII)
Cadena (sin guiones): 32 bytes (ASCII)

La mayoría de las bases de datos almacenan los UUIDs en formato binario internamente. El tipo nativo uuid de PostgreSQL usa exactamente 16 bytes.

¿Debería usar UUID o auto-incremento para las claves primarias?

El auto-incremento es más simple para aplicaciones de base de datos única (más pequeño, más rápido, secuencial). UUID es mejor para sistemas distribuidos (generar en cualquier lugar, sin coordinación, seguro para fusiones). Si usas UUID, prefiere v7 para el mejor rendimiento de base de datos.

¿Qué es RFC 9562?

RFC 9562, publicado en mayo de 2024, es el último estándar UUID. Reemplaza RFC 4122 e introduce formalmente las versiones UUID 6, 7 y 8. Depreca v1 en favor de v6/v7 y define los valores UUID nil y max. Si estás implementando generación o validación de UUID, RFC 9562 es la referencia autoritativa.

¿Puedo usar UUIDs entre diferentes lenguajes de programación?

Sí. El formato UUID (128 bits, hex 8-4-4-4-12) es independiente del lenguaje. Un UUID generado en JavaScript será correctamente analizado en Python, Go, Java o cualquier otro lenguaje con soporte UUID. Esta interoperabilidad es una de las mayores fortalezas de UUID.

Genera, decodifica y valida UUIDs al instante con nuestro Generador de UUID — soporta v1, v4, v5 y v7 con generación en lote, 100% en tu navegador.

¿Eligiendo entre versiones de UUID para tu próximo proyecto? Lee nuestra comparación de UUID v4 vs v7 vs ULID vs Snowflake para una guía de selección práctica con benchmarks de base de datos y ejemplos de código.