¿Qué es un UUID?

Un UUID (Universally Unique Identifier, identificador único universal) es una etiqueta de 128 bits que se usa para identificar información en los sistemas informáticos. Estandarizado en el RFC 4122 (y actualizado por el RFC 9562 en 2024), un UUID se escribe normalmente en esta forma canónica:

Guía completa de UUID: versiones, casos de uso y cómo elegir entre v4 y v7

550e8400-e29b-41d4-a716-446655440000

Ocho caracteres hexadecimales y luego grupos de cuatro, cuatro, cuatro y doce: siempre 32 dígitos hexadecimales más cuatro guiones, 36 caracteres en total.

La promesa fundamental de un UUID es que puedes generarlo en cualquier máquina y en cualquier momento con una probabilidad astronómicamente baja de que colisione con cualquier otro UUID generado alguna vez. Eso es lo que los hace valiosísimos en sistemas distribuidos en los que no se puede coordinar con una autoridad central de IDs.


Referencia completa de versiones

La especificación de UUID define varias versiones, cada una con una estrategia de generación distinta.

Versión Estrategia de generación ¿Ordenable? Cuándo usarla
v1 Dirección MAC + marca de tiempo Parcialmente Sistemas heredados, pistas de auditoría
v2 Seguridad DCE (UID/GID de POSIX) No Casi nunca
v3 Hash MD5 del espacio de nombres + nombre No IDs deterministas a partir de entradas conocidas (heredado)
v4 Aleatorio No Uso general, IDs de sesión
v5 Hash SHA-1 del espacio de nombres + nombre No IDs deterministas a partir de entradas conocidas
v6 Marca de tiempo + aleatorio (v1 reordenado) Sí Sustituto ordenado de v1
v7 Marca de tiempo Unix en ms + aleatorio Sí Claves primarias de bases de datos (recomendado)
v8 Formato personalizado Varía Formatos específicos de una aplicación

Versión 1: dirección MAC + marca de tiempo

UUID v1 codifica la dirección MAC de la máquina generadora y una marca de tiempo de 100 nanosegundos. El riesgo de colisión es extremadamente bajo porque la combinación de identidad de la máquina y tiempo es única.

La desventaja: las direcciones MAC permiten identificar a una persona. Generar UUID v1 en una aplicación web puede revelar sin querer detalles del hardware del servidor. Por eso v1 ha caído en gran parte en desuso en los sistemas nuevos.

Versión 3 y versión 5: UUID deterministas

Tanto v3 como v5 generan un UUID a partir de un UUID de espacio de nombres y una cadena de nombre mediante una función hash (MD5 en v3, SHA-1 en v5). Con las mismas entradas, se obtiene siempre el mismo UUID.

Esto es útil para crear identificadores estables a partir de datos externos:

// Ejemplo de v5: la misma URL produce siempre el mismo UUID
// El UUID de espacio de nombres para URL está definido en el RFC 4122
const DNS_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
uuidv5('example.com', DNS_NAMESPACE); // siempre el mismo resultado

Usa v5 en lugar de v3 siempre que sea posible: SHA-1 es más fuerte que MD5, aunque ninguno de los dos es adecuado para fines criptográficos en diseños nuevos.

Versión 4: el caballo de batalla

UUID v4 son simplemente 122 bits de datos aleatorios criptográficamente seguros (los 6 bits restantes codifican la versión y la variante). Es el tipo de UUID que más se genera en el mundo.

// Navegador / Node.js (integrado, no hace falta biblioteca)
const id = crypto.randomUUID(); // "f47ac10b-58cc-4372-a567-0e02b2c3d479"

// Python
import uuid
print(uuid.uuid4())  # 3d6f4890-4f40-4d09-aa11-3efb...

// Go
import "github.com/google/uuid"
id := uuid.New()

Probabilidad de colisión: si generaras mil millones de UUID v4 por segundo durante 86 años, la probabilidad de una sola colisión sería de aproximadamente el 50 %. A efectos prácticos, las colisiones son prácticamente imposibles.

Limitación: los UUID v4 son aleatorios, es decir, no son ordenables. Insertar UUID aleatorios como claves primarias en un índice B-tree provoca con el tiempo fragmentación del índice, lo que perjudica el rendimiento de escritura a gran escala.

Versión 7: el estándar moderno

UUID v7 se estandarizó en el RFC 9562 (mayo de 2024). Coloca una marca de tiempo Unix en milisegundos en los bits más significativos, seguida de datos aleatorios.

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                           unix_ts_ms                          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|          unix_ts_ms           |  ver  |       rand_a          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|var|                        rand_b                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                            rand_b                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Como la marca de tiempo está en los bits altos, los UUID v7 son ordenables lexicográficamente por el momento de generación. Dos UUID generados en secuencia se ordenarán en ese orden, justo lo que quieren los índices de las bases de datos.

// Con el paquete 'uuidv7'
import { uuidv7 } from 'uuidv7';

const id1 = uuidv7(); // "018e1f27-42a0-7000-8000-..."
const id2 = uuidv7(); // "018e1f27-42a1-7000-..."
// id1 < id2 (la comparación de cadenas da el orden correcto)

UUID frente a IDs enteros secuenciales

Para las claves primarias de bases de datos, la elección tradicional eran los enteros autoincrementales (SERIAL, AUTO_INCREMENT). Los UUID cambian ese equilibrio.

Aspecto Entero autoincremental UUID v4 UUID v7
Previsibilidad del ID Adivinable (enumerable) Impredecible Impredecible
Rendimiento del índice Excelente (secuencial) Deficiente (escrituras aleatorias) Excelente (ordenado por tiempo)
Generación distribuida Requiere un coordinador central Cualquier nodo, en cualquier momento Cualquier nodo, en cualquier momento
Fusión / replicación Compleja Sencilla Sencilla
Sobrecoste por fila 4–8 bytes 16 bytes 16 bytes
Legibilidad para personas Fácil Difícil Difícil

Para la mayoría de los sistemas modernos, sobre todo los que ejecutan microservicios, gestionan despliegues multirregión o fusionan datos de varias fuentes, UUID v7 es la opción por defecto adecuada para las claves primarias.


Generar UUID en lenguajes habituales

JavaScript / TypeScript

// v4 — integrado en los navegadores modernos y en Node.js 14.17+
const sessionId = crypto.randomUUID();

// v7 — instala el paquete uuidv7
import { uuidv7 } from 'uuidv7';
const recordId = uuidv7();

Python

import uuid

# v4
print(uuid.uuid4())

# v7 — disponible en Python 3.12+ mediante una biblioteca de terceros
# pip install uuid7
from uuid7 import uuid7
print(uuid7())

Go

import "github.com/google/uuid"

// v4
id := uuid.New()

// v7
id, err := uuid.NewV7()

PostgreSQL

-- v4 integrado (requiere pgcrypto o pg 13+)
SELECT gen_random_uuid();

-- v7 con pgx o generación en la aplicación
INSERT INTO users (id, email) VALUES ($1, $2)
-- pasa uuidv7() desde la capa de aplicación

Consideraciones prácticas

Guardar UUID en bases de datos

  • PostgreSQL: usa el tipo nativo UUID. Se guarda en 16 bytes, no como cadenas de 36 caracteres.
  • MySQL/MariaDB: usa BINARY(16) por eficiencia o CHAR(36) por legibilidad. Inserta con UUID_TO_BIN(uuid, true) para conservar la ordenabilidad.
  • SQLite: guárdalo como BLOB(16) o TEXT(36).

Almacenamiento como cadena o como binario

Un UUID como cadena de texto ("f47ac10b-58cc-4372-a567-0e02b2c3d479") ocupa 36 bytes. Como binario sin procesar ocupa 16 bytes. Con millones de filas, esa diferencia es significativa tanto en almacenamiento como en el tamaño del índice.

UUID seguros para URL

Los UUID estándar son seguros para URL porque solo contienen dígitos hexadecimales y guiones. Sin embargo, si quieres una representación aún más compacta para usarla en URL, puedes quitar los guiones (32 caracteres) o usar la codificación Base64Url (22 caracteres).


Novedades de noviembre de 2026

  • Ahora se pueden generar NanoID (caracteres y longitud a elección, sin sesgo, con estimación de colisión), KSUID (con lectura de la hora) y UUID v1 / v6 basados en el tiempo.
  • El nodo de v1 / v6 es aleatorio (con el bit multicast) y nunca una dirección MAC. v6 se ordena por tiempo incluso como texto, lo que conviene a las claves primarias.

Pruébalo en la herramienta

Preguntas frecuentes

¿Es UUID v4 realmente aleatorio?

UUID v4 usa 122 bits de datos aleatorios (los otros 6 bits están fijados para la versión y la variante). Que sea “realmente” aleatorio depende del generador de números aleatorios. La mayoría de los entornos modernos usan un generador de números pseudoaleatorios criptográficamente seguro (CSPRNG), adecuado para usos sensibles a la seguridad. crypto.randomUUID() en los navegadores y en Node.js usa el CSPRNG del sistema.

¿Debo cambiar todos mis UUID v4 existentes a v7?

No: migrar los IDs existentes normalmente no compensa el esfuerzo. Las ventajas de v7 (ordenabilidad, localidad del índice) se aplican a las inserciones nuevas. Si tu sistema ya tiene UUID v4 y el rendimiento de los índices es aceptable, déjalos. Empieza a usar v7 en tablas o sistemas nuevos.

¿Pueden dos máquinas generar el mismo UUID v4?

En teoría sí, en la práctica no. Con 122 bits de aleatoriedad, tendrías que generar unos 2,7 × 10¹⁸ UUID para llegar a una probabilidad de colisión del 50 %. Generando mil millones de UUID por segundo entre todas las máquinas del mundo, eso tardaría más de 85 años.

¿Qué es un UUID nulo (nil)?

El UUID nil es todo ceros: 00000000-0000-0000-0000-000000000000. Se usa como valor centinela (parecido a null) para indicar “ningún UUID”. Algunos ORM lo usan como valor por defecto antes de asignar un ID.

¿Cómo valido el formato de un UUID?

Una comprobación sencilla con una regex:

const UUID_REGEX =
  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

UUID_REGEX.test('550e8400-e29b-41d4-a716-446655440000'); // true
UUID_REGEX.test('not-a-uuid'); // false

Para una validación específica de la versión, comprueba que la posición 14 (el dígito de versión) coincida con el número de versión esperado.