Generador de UUID Online Gratuito - v1, v3-v7

¿Qué es un UUID?

UUID (Identificador Único Universal) es un identificador de 128 bits utilizado en sistemas informáticos para identificar información de forma única. El UUID está estandarizado según RFC 4122 y, gracias a su enorme entropía, garantiza una probabilidad de colisión prácticamente nula; esto significa que dos UUID generados de forma independiente serán casi con certeza únicos.

El UUID tiene un formato estándar: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, donde cada x es un dígito hexadecimal (0-9, a-f), M indica la versión del UUID y N indica la variante.

Versiones de UUID

UUID v1 (Marca de tiempo + dirección MAC)

El UUID v1 se basa en una marca de tiempo actual y un valor aleatorio (en el navegador, en lugar de la dirección MAC). Utiliza intervalos de 100 nanosegundos desde el 15 de octubre de 1582 (calendario gregoriano).

Uso:

• Situaciones en las que se necesita ordenar los UUID cronológicamente
• Depuración y registro (el UUID contiene información sobre la hora de creación)
• Sistemas distribuidos con sincronización de tiempo

Ejemplo: 6ba7b810-9dad-11d1-80b4-00c04fd430c8

Ventajas:

• Los UUID se pueden ordenar cronológicamente por la hora de creación
• Útil para auditoría y depuración
• Contiene información de marca de tiempo

Desventajas:

• Potencial riesgo de seguridad: contiene una marca de tiempo
• En el navegador no contiene una dirección MAC real (reemplazada por un valor aleatorio)
• Mala localidad de la base de datos (la marca de tiempo está en los bits de orden bajo)

UUID v3 (Hash MD5)

El UUID v3 se genera utilizando el hash MD5 de un namespace UUID y un nombre. Es determinista: el mismo namespace + nombre siempre generará el mismo UUID.

Uso:

• Conversión de URL, nombres DNS u otros identificadores a UUID
• Situaciones en las que se necesita un UUID reproducible
• Mapeo entre diferentes sistemas de identificación

Ejemplo: a3bb189e-8bf9-3888-9912-ace4e6543002

Ventajas:

• Determinista (misma entrada = misma salida)
• Ideal para la conversión de identificadores conocidos
• No hay colisiones para diferentes entradas

Desventajas:

• MD5 es un algoritmo obsoleto (prefiera v5)
• Requiere un namespace y un nombre
• No se puede recuperar la entrada original

UUID v4 (Aleatorio) - RECOMENDADO

La versión más utilizada de UUID. El UUID v4 se genera de forma puramente aleatoria utilizando un generador de números aleatorios criptográficamente seguro (crypto.getRandomValues()).

Uso:

• Claves primarias de bases de datos
• Identificadores de sesión (session IDs)
• Nombres de archivo únicos
• Tokens de API
• Propósitos generales donde se necesita una ID garantizada y única

Ejemplo: f47ac10b-58cc-4372-a567-0e02b2c3d479

Ventajas:

• Máxima entropía y seguridad
• No depende del tiempo ni de parámetros del sistema
• Implementación más sencilla

Probabilidad de colisión: Al generar mil millones de UUID por segundo durante 100 años, la probabilidad de colisión es aproximadamente del 0.00000006%.

UUID v5 (Hash SHA-1)

El UUID v5 es igual que el v3, pero utiliza SHA-1 en lugar de MD5. Una alternativa más moderna y segura a la v3.

Uso:

• Igual que v3, pero con mejor seguridad
• Preferido sobre v3 para nuevos proyectos
• Generación de UUID a partir de URL, nombres DNS, OID, X.500 DN

Ejemplo: 886313e1-3b8a-5372-9b90-0c9aee199e5d

Ventajas:

• Determinista
• SHA-1 es más robusto que MD5
• Adecuado para el mapeo entre sistemas

Desventajas:

• SHA-1 también se considera obsoleto (pero sigue siendo más seguro que MD5)
• Requiere un namespace y un nombre

UUID v6 (Marca de tiempo ordenada)

El UUID v6 es una versión mejorada de v1 con bits de tiempo reordenados para una mejor indexación en la base de datos. Diseñado para resolver problemas de localidad en bases de datos.

Uso:

• Claves primarias de bases de datos con ordenación temporal
• Sistemas que requieren ordenación cronológica y rendimiento de la base de datos
• Alternativa más moderna a v1

Ejemplo: 1ec9414c-232a-6b00-b3c8-9e6bdeced846

Ventajas:

• Mejor localidad de la base de datos que v1 (marca de tiempo en los bits de orden superior)
• Ordenación cronológica
• Compatible con el estándar UUID

Desventajas:

• Menos utilizado que v1/v4
• Todavía contiene información de tiempo (riesgo de seguridad)

UUID v7 (Marca de tiempo Unix)

El UUID v7 utiliza una marca de tiempo Unix (milisegundos desde 1970) + bits aleatorios. La versión más reciente de UUID con la mejor localidad de base de datos.

Uso:

• Claves primarias de bases de datos modernas
• Sistemas que requieren rendimiento + ordenación temporal
• Reemplazo de v1/v6 en nuevos proyectos

Ejemplo: 017f22e2-79b0-7cc3-98c4-dc0c0c07398f

Ventajas:

• La mejor localidad de base de datos de todas las versiones
• La marca de tiempo Unix es estándar
• Combina las ventajas de la aleatoriedad y la ordenación temporal

Desventajas:

• Especificación relativamente nueva (RFC 4122bis)
• Menos compatible en sistemas heredados

¿Qué versión de UUID usar?

Guía de decisión

¿Necesita máxima seguridad y aleatoriedad? → Use UUID v4 (la opción más común)

¿Necesita ordenación temporal y rendimiento de la base de datos? → Use UUID v7 (moderno) o UUID v6 (estándar)

¿Necesita UUID reproducibles a partir de identificadores existentes? → Use UUID v5 (SHA-1) o UUID v3 (MD5, legado)

¿Necesita una marca de tiempo y un rastro de auditoría? → Use UUID v1 (legado, peor rendimiento de la base de datos)

Bases de datos

Para nuevos proyectos: UUID v7 o v4

• v7 es ideal para ordenación temporal + rendimiento
• v4 para máxima aleatoriedad sin información de tiempo

Para sistemas heredados: UUID v1 o v6

• v6 tiene mejor localidad de base de datos que v1
• v1 es ampliamente compatible

Ventajas de UUID como clave primaria:

• Unicidad global – Puede unir datos de diferentes bases de datos sin conflicto
• Seguridad – A diferencia de los ID secuenciales (1, 2, 3…), no se pueden adivinar los valores siguientes
• Sistemas distribuidos – Los UUID se pueden generar de forma independiente en varios servidores sin coordinación
• Fusión de bases de datos – Al fusionar dos bases de datos, no surgen conflictos

Desventajas:

• Mayor tamaño (16 bytes vs 4-8 bytes para un entero)
• Indexación más lenta en algunas bases de datos (use v6/v7 para mejor rendimiento)
• Menos legible para el ser humano

API y servicios web

• REST API – Identificadores únicos para recursos
• GraphQL – Identificadores globales para nodos
• Webhooks – Seguimiento de solicitudes y respuestas
• Tokens – IDs de sesión, tokens de actualización

Archivos y almacenamiento

• Nombres de archivo – Prevención de colisiones al cargar
• S3/Almacenamiento en la nube – Rutas de objetos únicas
• Claves de caché – Identificadores en sistemas de caché

Aplicaciones Frontend

• Componentes React/Vue – Claves únicas para listas
• IDs temporales – ID antes de guardarse en la base de datos
• Almacenamiento local – Claves para datos guardados
• Aplicaciones offline-first – Generación de ID sin conexión al servidor

Funciones avanzadas del generador

Generación de UUID con tiempo personalizado

Para versiones basadas en el tiempo (v1, v6, v7) puede seleccionar cualquier marca de tiempo utilizando el selector de fecha y hora. Esto es útil para:

Pruebas:

• Simulación de UUID creados en el pasado
• Pruebas de ordenación temporal en bases de datos
• Reproducción de UUID para depuración

Migración de datos:

• Generación de UUID con marcas de tiempo históricas
• Relleno de datos con valores de marca de tiempo correctos
• Importación de datos de diferentes períodos de tiempo

Auditoría y cumplimiento:

• Reconstrucción de UUID según la hora de creación del registro
• Generación retroactiva de identificadores

Ejemplo de uso:

1. Seleccione la versión v1, v6 o v7
2. Establezca la fecha y hora utilizando el selector de fecha y hora
3. Genere UUID con su propia marca de tiempo

UUID basados en hash (v3, v5)

Para UUID deterministas, puede usar las versiones v3 (MD5) o v5 (SHA-1):

Cómo usar:

1. Seleccione un namespace según el tipo de su identificador
2. Ingrese el nombre/valor
3. Genere el UUID

Ejemplos:

Propiedades importantes:

• ✅ Determinista: Misma entrada = siempre el mismo UUID
• ✅ Reproducible: Puede recrear el UUID en cualquier momento
• ✅ Consistente: El mismo UUID en diferentes sistemas
• ❌ No se puede decodificar: No se puede obtener el nombre original a partir del UUID
• ℹ️ Un solo UUID: Para v3/v5, siempre se genera solo un UUID (misma entrada = misma salida)

Uso práctico:

// Ejemplo: Conversión de URL a UUID en v5
Namespace: URL
Nombre: https://example.com/api/users/123
Resultado: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Misma entrada = siempre el mismo UUID
Namespace: DNS
Nombre: google.com
Resultado: siempre el mismo UUID para google.com

¿Cómo usar UUID de forma segura?

Seguridad criptográfica

Nuestro generador utiliza crypto.getRandomValues(), que es un generador de números aleatorios criptográficamente seguro. A diferencia de Math.random(), que es predecible e inadecuado para fines de seguridad, crypto.getRandomValues() proporciona una entropía real adecuada para:

• Generación de tokens de seguridad
• IDs de sesión
• Claves de API
• Aplicaciones criptográficas

Comparación de versiones de UUID

UUID vs otros identificadores

Implementación en diferentes lenguajes

JavaScript/TypeScript

// UUID v4 - La forma más sencilla (navegadores modernos)
const uuid = crypto.randomUUID();

// UUID v4 - Implementación manual
function generateUUIDv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0x0f) >> (c === 'x' ? 0 : 2);
    const v = c === 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

// UUID v7 - Recomendado para bases de datos
function generateUUIDv7() {
  const timestamp = Date.now();
  const timeHi = (timestamp >> 16).toString(16).padStart(8, '0');
  const timeLow = (timestamp & 0xFFFF).toString(16).padStart(4, '0');

  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
  const randomHex = Array.from(randomBytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');

  return `${timeHi}-${timeLow}-7${randomHex.substr(0, 3)}-${randomHex.substr(3, 4)}-${randomHex.substr(7)}`;
}

Python

import uuid

# UUID v4
uuid_v4 = str(uuid.uuid4())
# Salida: '6ba7b810-9dad-11d1-80b4-00c04fd430c8'

# UUID v1
uuid_v1 = str(uuid.uuid1())

Java

import java.util.UUID;

// UUID v4
String uuidV4 = UUID.randomUUID().toString();

PHP

// UUID v4 (PHP 7+)
function generateUUID() {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}

C#

using System;

// UUID v4
Guid uuid = Guid.NewGuid();
string uuidString = uuid.ToString();

Mejores Prácticas

Almacenamiento de UUID en la base de datos

PostgreSQL:

CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

MySQL 8.0+:

CREATE TABLE users (
    id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Consejo: En MySQL, guarde los UUID como BINARY(16) en lugar de CHAR(36) para ahorrar espacio y una indexación más rápida.

Validación de UUID

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

Conversión de UUID

// Eliminación de guiones
const compact = uuid.replace(/-/g, '');

// Adición de guiones de nuevo
function formatUUID(compactUuid) {
  return [
    compactUuid.substring(0, 8),
    compactUuid.substring(8, 12),
    compactUuid.substring(12, 16),
    compactUuid.substring(16, 20),
    compactUuid.substring(20, 32)
  ].join('-');
}

Solución de Problemas

UUID v3/v5 no funciona

Problema: Después de seleccionar v3 o v5, no se genera nada

Solución:

1. ✅ Compruebe que ha rellenado el campo “Nombre” - ¡es obligatorio!
2. ✅ Seleccione el namespace correcto según el tipo de su entrada
3. ✅ Ejemplos de entradas válidas:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • Cualquier texto: mi-aplicacion-v1

Consejo: Pruebe primero un valor simple como test y el namespace DNS.

UUID temporal (v1, v6, v7) tiene una hora extraña

Problema: El UUID generado tiene una marca de tiempo inesperada

Solución:

1. ✅ Compruebe el selector de fecha y hora - ¿está configurado correctamente?
2. ✅ El selector de fecha y hora utiliza su zona horaria local
3. ✅ Deje el selector de fecha y hora vacío para la hora actual

El UUID no se puede copiar

Problema: El botón “Copiar todo” no funciona

Solución:

1. ✅ Compruebe que ha generado UUID (no están vacíos)
2. ✅ Algunos navegadores requieren HTTPS para la API del portapapeles
3. ✅ Alternativamente, seleccione el texto en el área de texto y cópielo manualmente (Ctrl+C)

Preguntas Frecuentes

Alternativas a UUID

ULID (Identificador Universal Único Lexicográficamente Ordenable)

• ID de 128 bits (igual que UUID)
• Ordenable lexicográficamente por la hora de creación
• Representación más compacta (26 caracteres en lugar de 36)
• Codificación base32 insensible a mayúsculas y minúsculas

Ejemplo: 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• Tamaño más pequeño que UUID (21 caracteres por defecto)
• Amigable para URL (sin caracteres especiales)
• Generación más rápida
• Longitud y alfabeto configurables

Ejemplo: V1StGXR8_Z5jdHi6B-myT

Snowflake ID (Twitter)

• ID de 64 bits (más pequeño que UUID)
• Ordenable por tiempo
• Contiene ID de trabajador y número de secuencia
• Requiere configuración centralizada

Ejemplo: 1234567890123456789

Rendimiento y optimización

Velocidad de generación

Nuestro generador puede generar:

• 1 UUID: < 1 ms
• 100 UUID: ~10-20 ms
• 1000 UUID: ~100-200 ms

Consejos de rendimiento

1. Generación por lotes – Si necesita muchos UUID, genérelos todos a la vez en lugar de uno por uno
2. Almacenamiento en DB – Indexe las columnas UUID para una búsqueda rápida
3. Compresión – Almacene los UUID en formato binario (16 bytes) en lugar de cadena (36 bytes)
4. Caché – En algunos casos, puede pregenerar y almacenar en caché los UUID

Para desarrolladores

Estructura de UUID v4

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bits de datos aleatorios (nodo)
|        |    |    └────── 16 bits de datos aleatorios con variante (clock_seq)
|        |    └─────────── 12 bits de datos aleatorios + 4 bits de versión (time_hi_and_version)
|        └──────────────── 16 bits de datos aleatorios (time_mid)
└───────────────────────── 32 bits de datos aleatorios (time_low)

• Versión (4 bits): siempre 0100 (binario) = 4 (hex)
• Variante (2-3 bits): siempre 10 (binario) para RFC 4122

Pruebas de UUID

// Jest test
describe('UUID Generator', () => {
  test('generates valid UUID v4', () => {
    const uuid = generateUUIDv4();
    const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    expect(regex.test(uuid)).toBe(true);
  });

  test('generates unique UUIDs', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});

Aspectos de seguridad

Lo que NO se debe hacer con los UUID

❌ No use UUID v1 para aplicaciones sensibles – Contiene una marca de tiempo, lo que puede ser un riesgo de seguridad

❌ No use Math.random() para generar UUID – No es criptográficamente seguro

❌ No dependa de los UUID para la autorización – Los UUID se pueden adivinar (aunque con una probabilidad extremadamente baja)

❌ No almacene UUID en cookies sin cifrado – Use cookies firmadas o JWT

Lo que SÍ se debe hacer

✅ Use UUID v4 para la mayoría de los casos – La mayor entropía y seguridad

✅ Combine UUID con otras medidas de seguridad – Para la gestión de sesiones, use HTTPS, cookies HttpOnly y una expiración corta

✅ Valide los UUID en el servidor – Siempre verifique el formato y la versión del UUID

✅ Use fuentes de aleatoriedad criptográficamente seguras – crypto.getRandomValues() en el navegador, /dev/urandom en Linux

Curiosidades

• Número de posibles UUID v4: 2^122 ≈ 5.3 × 10^36 (340 undecillones)
• Colisión necesaria: Para una probabilidad del 50% de colisión, debe generar 2.71 × 10^18 UUID (2.71 quintillones)
• Tamaño de todos los posibles UUID: Si cada UUID se almacenara como 16 bytes, el espacio total ocuparía 85 zettabytes (85 mil millones de terabytes)
• Origen: UUID fue estandarizado como parte de DCE (Distributed Computing Environment) en 1990