Una UUID (Universally Unique Identifier, identificador único universal) es un identificador de 128 bits (16 bytes) considerado único en la práctica, incluso generado sin una autoridad central. Como texto estándar se escribe con 32 caracteres hexadecimales y 4 guiones, agrupados en 8-4-4-4-12 (por ej. 550e8400-e29b-41d4-a716-446655440000). Esta herramienta puede generar cada versión definida por la RFC 4122 y la actual RFC 9562 — v1, v3, v4, v5 y v7.
¿Qué es una UUID, y cuáles son sus versiones?
Una explicación completa de las versiones de UUID según la RFC 4122/9562, cuándo usar cada una, y en qué se diferencia un GUID.
Mini-herramientas adicionales: UUID NIL, ULID, Base64, NanoID y UUID→ULID
Cinco mini-herramientas adicionales inspiradas en herramientas UUID de la competencia: una UUID vacía fija, un identificador ULID ordenable, un convertidor de UUID a Base64/Hex, un generador NanoID configurable y un convertidor de UUID (v1/v7) a ULID.
Tablas de referencia de versiones UUID y formatos
Una comparación citable de versiones, ejemplos de formato, y una comparación UUID/GUID/ULID.
| Versión | Origen de los datos | ¿Ordenable? | Uso típico |
|---|---|---|---|
| v1 | Marca de tiempo + identificador de nodo | Parcialmente | Sistemas heredados, compatibilidad |
| v3 | Namespace + nombre (MD5) | No | Identificador determinista (histórico) |
| v4 | Completamente aleatoria | No | Uso general, la más común |
| v5 | Namespace + nombre (SHA-1) | No | Identificador determinista (recomendada) |
| v7 | Marca de tiempo + aleatoria | Sí | Claves primarias de bases de datos |
| ULID (extra) | Marca de tiempo + aleatoria (Base32) | Sí | Identificador ordenable, cadena corta |
| Formato | Ejemplo |
|---|---|
| Estándar (minúsculas) | 550e8400-e29b-41d4-a716-446655440000 |
| Mayúsculas | 550E8400-E29B-41D4-A716-446655440000 |
| Sin guiones | 550e8400e29b41d4a716446655440000 |
| Llaves (GUID .NET) | {550e8400-e29b-41d4-a716-446655440000} |
| Prefijo URN | urn:uuid:550e8400-e29b-41d4-a716-446655440000 |
| Base64 (16 bytes) | VQ6EAOKbQdSnFkRmVUQAAA== |
| Propiedad | UUID | GUID | ULID |
|---|---|---|---|
| Longitud en bits | 128 | 128 (mismo estándar) | 128 |
| Longitud en texto | 36 caracteres | 36 (o 38 con llaves) | 26 caracteres |
| Alfabeto | Hexadecimal (0-9, a-f) + guiones | Hexadecimal + guiones | Crockford Base32 |
| ¿Ordenable cronológicamente? | Solo v1/v7 | Solo v1/v7 | Sí (por defecto) |
| Uso habitual | Uso general | Ecosistema .NET / Windows | Claves de base de datos, IDs de logs |
Ejemplos de código por lenguaje: cómo generar una UUID
Código listo para copiar para generar UUID/GUID en Python, JavaScript/Node, Java, C#, Go, PHP, PostgreSQL y MySQL. Cada ejemplo muestra el enfoque estándar del lenguaje en cuestión.
uuid, sin necesidad de instalación.# Librería estándar, sin necesidad de instalación import uuid # v4 (aleatoria) — el uso más común print(uuid.uuid4()) # 550e8400-e29b-41d4-a716-446655440000 # v5 (basada en nombre, SHA-1) — determinista print(uuid.uuid5(uuid.NAMESPACE_DNS, "example.com")) # v1 (tiempo + nodo) print(uuid.uuid1()) # Formatos de texto u = uuid.uuid4() print(u.hex) # sin guiones print(str(u).upper()) # mayúsculas
crypto.randomUUID() integrado en navegadores modernos y Node 19+.// Navegador + Node 19+ (integrado, v4)
const id = crypto.randomUUID();
console.log(id); // 550e8400-e29b-41d4-a716-446655440000
// Node.js (vía el módulo crypto)
import { randomUUID } from "node:crypto";
console.log(randomUUID());
// Mayúsculas / sin guiones
console.log(id.toUpperCase());
console.log(id.replace(/-/g, ""));
java.util.UUID (v4 aleatoria y v3 basada en nombre).import java.util.UUID;
// v4 (aleatoria)
UUID id = UUID.randomUUID();
System.out.println(id); // 550e8400-e29b-41d4-a716-446655440000
// v3 (basada en nombre, MD5)
UUID named = UUID.nameUUIDFromBytes("example.com".getBytes());
System.out.println(named);
// Análisis a partir de texto
UUID parsed = UUID.fromString("550e8400-e29b-41d4-a716-446655440000");
Guid. .NET 9 añade también Guid.CreateVersion7(), ordenada por tiempo.using System;
// GUID de tipo v4 (aleatoria)
Guid id = Guid.NewGuid();
Console.WriteLine(id); // 550e8400-e29b-41d4-a716-446655440000
Console.WriteLine(id.ToString("B")); // {550e8400-...} formato GUID .NET
Console.WriteLine(id.ToString("N")); // sin guiones
Console.WriteLine(id.ToString("D").ToUpper()); // mayúsculas
// .NET 9+: v7 (ordenada por tiempo, adecuada para bases de datos)
Guid v7 = Guid.CreateVersion7();
github.com/google/uuid (go get github.com/google/uuid).package main
import (
"fmt"
"github.com/google/uuid"
)
func main() {
fmt.Println(uuid.New()) // v4 (aleatoria)
// v5 (basada en nombre, SHA-1)
fmt.Println(uuid.NewSHA1(uuid.NameSpaceDNS, []byte("example.com")))
// v7 (ordenada por tiempo) — google/uuid v1.6+
v7, _ := uuid.NewV7()
fmt.Println(v7)
}
ramsey/uuid (composer require ramsey/uuid).use Ramsey\Uuid\Uuid; // v4 (aleatoria) echo Uuid::uuid4()->toString(); // 550e8400-e29b-41d4-a716-446655440000 // v7 (ordenada por tiempo, adecuada para bases de datos) echo Uuid::uuid7()->toString(); // v5 (basada en nombre, SHA-1) — determinista echo Uuid::uuid5(Uuid::NAMESPACE_DNS, "example.com")->toString();
gen_random_uuid() está integrada desde la versión 13 (las versiones anteriores necesitan la extensión pgcrypto).-- Generar una UUID v4 (aleatoria) SELECT gen_random_uuid(); -- Valor por defecto automático en una columna de tabla CREATE TABLE users ( id uuid PRIMARY KEY DEFAULT gen_random_uuid(), name text NOT NULL ); -- Versiones anteriores (PostgreSQL 12 y anteriores): -- CREATE EXTENSION IF NOT EXISTS pgcrypto;
UUID() genera un valor de tipo v1; se recomienda UUID_TO_BIN(..., 1) para un almacenamiento ordenado.-- Generar una UUID en texto (tipo v1) SELECT UUID(); -- Almacenar como BINARY ordenado de 16 bytes (optimizado para el índice) SELECT UUID_TO_BIN(UUID(), 1); CREATE TABLE users ( id BINARY(16) PRIMARY KEY, name VARCHAR(120) NOT NULL ); -- Volver a convertir a texto al leer: -- SELECT BIN_TO_UUID(id, 1) FROM users;
Glosario de términos UUID
Definiciones breves de los conceptos esenciales usados al hablar de UUID/GUID.
Guías detalladas
Respuestas detalladas a las preguntas más habituales sobre UUID.
¿Qué versión de UUID debería usar?
Para la mayoría de los escenarios, v4 (completamente aleatoria) es una buena opción por defecto: simple, respetuosa con la privacidad, y no revela ninguna información. Si la usas como clave primaria de base de datos y el rendimiento del índice importa, prefiere v7; como los valores v7 generados secuencialmente se ordenan cronológicamente, causan menos fragmentación en los índices de árbol B.
Si siempre necesitas derivar el mismo identificador a partir de la misma entrada (por ej. una URL o una dirección de correo), usa v5 (basada en SHA-1); v3 (basada en MD5) se conserva solo por compatibilidad con sistemas heredados. Recurre a v1 únicamente cuando trabajes con sistemas antiguos que la requieran por compatibilidad.
Para una clave primaria de base de datos: ¿UUID, autoincremental, o ULID?
Los enteros autoincrementales indexan más rápido, pero pueden colisionar en sistemas distribuidos (cuando varios servidores insertan registros simultáneamente) y revelan públicamente el número de filas. Una UUID v4 nunca colisiona, pero al ser completamente aleatoria, puede fragmentar los índices de árbol B y ralentizar las escrituras.
La UUID v7 o ULID resuelve este problema gracias a un prefijo con marca de tiempo: ninguna de las dos colisiona, y como se insertan en orden, su rendimiento de indexación se acerca al del autoincremental. ULID es también más corto (26 caracteres frente a 36 de la UUID); la elección suele depender de lo que admita tu ecosistema (ORM/base de datos).
¿Cuál es realmente la probabilidad de colisión de una UUID v4?
Una UUID v4 tiene 122 bits generados aleatoriamente, lo que da 2122 (≈5,3 × 1036) valores posibles. Según el cálculo de la paradoja del cumpleaños, haría falta generar unos 2,71 billones (2,71 × 1018) de UUID antes de alcanzar un 50% de probabilidad de colisión — una escala prácticamente imposible, equivalente a que cada persona en la Tierra generara miles de millones de UUID cada segundo.
Por eso, las UUID v4 se consideran con total seguridad «únicas» en aplicaciones reales. Dicho esto, la calidad del generador de números aleatorios importa; esta herramienta usa el criptográfico crypto.getRandomValues en lugar del inseguro Math.random().
Añade esta herramienta a tu sitio (código de inserción)
Incorpora gratis el generador UUID en tu propio sitio. Copia el código a continuación en tu HTML — la herramienta se muestra en una vista simplificada y enlaza a esta página como fuente.
La herramienta insertada tiene un diseño fijo; puedes ajustar el valor de height según tu sitio. Sin publicidad ni datos personales, funciona íntegramente en el cliente.
Preguntas frecuentes
¿Qué es una UUID?
¿Cómo se genera una UUID v4?
¿Cuál es la diferencia entre un GUID y una UUID?
¿Cómo se generan UUID en lote?
¿Cuántos caracteres o bytes tiene una UUID?
¿Es seguro usar un generador de UUID online?
¿Cuál es la diferencia entre UUID v1 y v4?
¿Qué es un ULID, y en qué se diferencia de una UUID?
¿Cómo saber cuándo se generó una UUID v7 o v1?
¿Cómo se genera una UUID en Python, C#, PostgreSQL y lenguajes similares?
uuid.uuid4(),
JavaScript/Node crypto.randomUUID(), Java UUID.randomUUID(), C#/.NET Guid.NewGuid(),
Go uuid.New(), PHP Uuid::uuid4(), PostgreSQL gen_random_uuid(), MySQL UUID().
Los ejemplos basados en nombre (v5) y ordenados por tiempo (v7) están en la misma sección.Metodología y fuentes
Fuentes: RFC 4122 (A Universally Unique IDentifier) · RFC 9562 (el estándar UUID actual, que añade v6/v7/v8) · W3C Web Cryptography API · la especificación oficial de ULID (Crockford Base32). Última actualización: 26 de julio de 2026. Los resultados son algorítmicos; v3/v5 son deterministas, mientras que v1/v4/v7 y ULID se basan en aleatoriedad criptográfica.