Tema

Herramientas populares

Generador de UUID

Genere al instante un UUID v4 aleatorio o un UUID v7 ordenado por tiempo, o hasta 10 000 a la vez. También es un generador de GUID online: un GUID nuevo es el mismo tipo de valor de 128 bits. Pegue cualquier UUID para decodificar su versión, su fecha de creación y cada campo.

RFC 9562 · crypto.getRandomValues · se crea y se lee en su navegador, no se envía nada

El dígito en color es la versión: el primer dígito del tercer grupo de todo UUID.

v4 · Aleatorio36 caracteres · 122 bits aleatorios
xxxxxxxx-xxxx-4xxx-Nxxx-xxxxxxxxxxxx
Anatomía · RFC 9562 §5.4128 bits · 32 dígitos hex · 36 caracteres
Pase el cursor sobre un campo o tóquelo para leerlo

Creado y leído en su navegador con crypto.getRandomValues; no se envía nada.

Formato

¿Qué es un UUID y qué significa UUID?

UUID significa Universally Unique Identifier (identificador único universal): una etiqueta de 128 bits que cualquier computadora puede crear por su cuenta y aun así esperar que ninguna otra cree la misma. Se escribe como 32 dígitos hexadecimales en cinco grupos, como 919108f7-52d1-4320-9bac-f847db4148a8.

El formato lo define la RFC 9562 (mayo de 2024), que reemplazó a la RFC 4122 y añadió las versiones 6, 7 y 8. Ningún registro central reparte los UUID: la unicidad viene del azar, de una marca de tiempo o del hash de un nombre, según la versión.

Las bases de datos los usan como claves primarias, las API como identificadores de solicitudes y de objetos, y los sistemas operativos para discos, particiones y componentes de software. GUID (Globally Unique Identifier) es el nombre que Microsoft da a lo mismo.

Un valor, cuatro tamañosRFC 9562 §4

UniversallyUniqueIDentifier

  1. 128 bits
  2. 16 bytes
  3. 32 dígitos hex
  4. 36 caracteres con los guiones919108f7-52d1-4320-9bac-f847db4148a8

GUIDel nombre que Microsoft da al mismo valor

El ejemplo de versión 4 de la RFC 9562 contado de cuatro maneras. La forma de texto añade cuatro guiones a los 32 dígitos hexadecimales: 36 caracteres.
Generador de UUID: un UUID v7 con su marca de tiempo, versión y bits aleatorios marcados campo a campo, y un lote de v7Generador de UUID: un UUID v7 con su marca de tiempo, versión y bits aleatorios marcados campo a campo, y un lote de v7Elija una versiónv4 aleatorio, v7 ordenado por tiempo, v5 basado en nombre y los demás, cada uno con su propio color.Un clicCópielo o cree uno nuevo; un lote de hasta 10 000 sale como texto, CSV, JSON o SQL.Cada campoLos bits que la RFC 9562 define para esta versión, con la hora que lleva un v7 ya leída.Cualquier formatoLlaves, sin guiones, mayúsculas, Base64url, un entero o el orden de bytes de .NET.
Un UUID v7 desarmado: la marca de tiempo de 48 bits, el dígito de versión, los bits de variante y la parte aleatoria. Seleccione un número para ver qué muestra cada parte.

Formato y longitud de un UUID: 36 caracteres

Un UUID tiene 128 bits, escritos como 32 dígitos hexadecimales y 4 guiones en grupos de 8, 4, 4, 4 y 12: 36 caracteres. El primer dígito del tercer grupo es la versión, y el primer dígito del cuarto grupo indica la variante: 8, 9, a o b en los UUID de la RFC 9562.

Así, 017f22e2-79b0-7cc3-98c4-dc0c0c07398f es versión 7, variante RFC. Mayúsculas, minúsculas y una mezcla de ambas son igual de válidas; la mayoría de las herramientas imprimen minúsculas, y uuidgen de macOS, mayúsculas. Sin guiones tiene 32 caracteres, entre llaves 38 (el formato B de .NET), como urn:uuid: 45 y en Base64url 22.

Una expresión regular que comprueba la forma RFC: ^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$ con el indicador que no distingue mayúsculas de minúsculas. Rechaza los UUID Nil y Max, que son válidos pero especiales; el decodificador de arriba los identifica.

La forma de textoRFC 9562 §4
017f22e28-79b04-7cc34-98c44-dc0c0c07398f12

32 dígitos hex + 4 guiones = 36 caracteres

xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxxM versión: 1–8N variante: 8, 9, a o b
Regex · sin distinguir mayúsculas^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
Los mismos 128 bits, escritos de otras formas
  • Estándar017f22e2-79b0-7cc3-98c4-dc0c0c07398f36
  • Sin guiones017f22e279b07cc398c4dc0c0c07398f32
  • Llaves {…}{017f22e2-79b0-7cc3-98c4-dc0c0c07398f}38
  • urn:uuid:urn:uuid:017f22e2-79b0-7cc3-98c4-dc0c0c07398f45
  • Base64urlAX8i4nmwfMOYxNwMDAc5jw22
  • Base64AX8i4nmwfMOYxNwMDAc5jw==24
  • Base58BihbxwwQ4NZZpKRH9JDCz21
  • Base3201FWHE4YDGFK1SHH6W1G60EECF26
  • Entero1989357241971137676463954034883508623hasta 39
  • Binario01 7f 22 e2 79 b0 7c c3 98 c4 dc 0c 0c 07 39 8f16 bytes
El propio ejemplo de v7 de la RFC 9562 en cada forma escrita. La regex rechaza a propósito los UUID Nil y Max: no tienen versión.

Versiones de UUID explicadas: de v1 a v8

La versión indica cómo se creó un UUID: v4 a partir de bits aleatorios, v7 a partir de la hora más bits aleatorios, v1 y v6 a partir de una marca de tiempo y un ID de nodo, v3 y v5 con el hash de un nombre, y v8 con una estructura propia de su creador.

Aquí no se generan las versiones 2 y 0: v2 (DCE Security) está reservada y la RFC 9562 no define su estructura, y 0 no es una versión. Los dos valores especiales no tienen versión: el UUID Nil es todo ceros y el UUID Max, todo unos (ffffffff-ffff-ffff-ffff-ffffffffffff, nuevo en la RFC 9562).

Para sistemas nuevos, la RFC 9562 recomienda v7 en lugar de v1 y v6, y v5 en lugar de v3. v4 sigue siendo la opción sencilla cuando el valor no debe revelar nada sobre cuándo se creó.

VersiónSus 128 bitsCreado a partir deSe ordena por tiempo
v1Tiempo + nodo · §5.1Hora (100 ns) + secuencia de reloj + nodoNo
v2DCE Security: reservada, sin estructura en la RFC 9562No se genera: sin estructura definida–
v3Nombre · MD5 · §5.3MD5 de un espacio de nombres + un nombreNo
v4Aleatorio · §5.4Bits aleatoriosNo
v5Nombre · SHA-1 · §5.5SHA-1 de un espacio de nombres + un nombreNo
v6v1 ordenable · §5.6Los campos de v1, con los bits altos de la hora primeroSí
v7Ordenado por tiempo · §5.7Tiempo Unix (ms) + bits aleatoriosSí
v8Personalizado · §5.8La estructura propia de su creadorNo
Nil§5.9Todo ceros: “sin valor”–
Max§5.10Todo unos: un valor centinela–
  • tiempo
  • aleatorio
  • hash
  • secuencia de reloj
  • nodo
  • versión
  • variante
Cada barra son los 128 bits de una versión tal como los dispone la RFC 9562, a partir de sus propios vectores de prueba. Solo v6 y v7 ponen la hora primero, así que solo ellas se ordenan por tiempo como texto.

UUID v7 vs v4: ¿cuál debería usar?

Use v7 para claves de bases de datos y todo lo que ordene o indexe: empieza con la fecha de creación, así que las filas nuevas caen al final del índice. Use v4 cuando el ID no deba revelar cuándo se creó: sus 122 bits libres son todos aleatorios.

Las claves v4 aleatorias reparten cada inserción por todo un índice B-tree, lo que divide páginas y obliga a mantener en memoria una parte mayor del índice; las claves v7 llegan en orden, como un número autoincremental, y aun así cualquier servidor puede crearlas sin consultar a una base de datos. Un v7 conserva 74 bits aleatorios por milisegundo, así que dos servidores que creen uno en el mismo instante siguen sin colisionar.

La contrapartida: cualquiera que vea un v7 puede leer el milisegundo en que se creó (pegue uno en el decodificador de arriba). Si eso importa, use v4, o use v7 solo internamente y muestre otro ID en público.

12 inserciones en un índice B-tree8 páginas hoja · 16 claves cada una
las claves v4 caen en cualquier parte7 páginas de 8 modificadas · 3 divisiones de página
Páginas por primer byte
00–1fdivisión
20–3f
40–5f
60–7f
80–9f
a0–bf
c0–dfdivisión
e0–ffdivisión
c100eb4b-4f3f-4b29-ad77-da7cd9d1eda592c97333-2db8-4fc2-b5b6-cedd8c7abede
las claves v7 caen al final1 página de 8 modificada · 0 divisiones de página
Páginas por el día en que se crearon las claves
17 oct
18 oct
19 oct
20 oct
21 oct
22 oct
23 oct
24 oct
01a16d3e-e1c0-70f6-99ec-6d454991b2fa01a16d3e-e1c0-70f6-99ec-6d45c2f6b35b
  • ya en el índice
  • libre
  • clave v4 nueva
  • clave v7 nueva
  • división de página: la mitad de sus claves pasa a una página nueva
Un modelo, no una prueba de rendimiento: páginas hoja de 16 claves. Las claves aleatorias encuentran páginas antiguas casi llenas y las dividen; los primeros bytes de v7 son la hora, así que las doce van a la página más reciente, que aún tiene espacio.

GUID vs UUID: ¿hay alguna diferencia?

Un GUID y un UUID son el mismo valor de 128 bits con la misma forma de texto; GUID es el nombre que le da Microsoft. Guid.NewGuid() en .NET crea un UUID aleatorio versión 4, y Guid.CreateVersion7() de .NET 9, uno versión 7.

La diferencia está en la memoria. La estructura GUID de Microsoft guarda sus tres primeros grupos como enteros little-endian, así que ToByteArray() de .NET da los primeros 8 bytes en un orden distinto del orden de bytes de red de la RFC 9562: 919108f7-52d1-… se convierte en los bytes f7 08 91 91 d1 52 …. El texto es el mismo; los bytes sin procesar que pasan de un sistema a otro hay que convertirlos. El decodificador muestra ambos órdenes.

El uniqueidentifier de SQL Server además ordena primero por sus últimos seis bytes, así que allí los valores v7 no se mantienen en orden de tiempo; NEWSEQUENTIALID() crea valores que sí lo hacen, aunque tras un reinicio pueden volver a empezar desde un valor más bajo y son fáciles de adivinar. Los GUID antiguos de COM pueden llevar los bits de variante propios de Microsoft en lugar de los de la RFC 9562; el decodificador nombra esa variante.

Un GUID, tres órdenes de bytes16 bytes
919108f7-52d1-4320-9bac-f847db4148a8
RFC 9562 orden de red
.NET Guid.ToByteArray()
SQL Server orden de uniqueidentifierLos últimos seis bytes deciden el orden
  • Data1 · 4 bytes, invertidos
  • Data2 · invertidos
  • Data3 · invertidos
  • Data4 · tal cual
El mismo texto en memoria: .NET guarda los tres primeros grupos en little-endian, y SQL Server ordena primero por los últimos seis bytes, así que allí las claves v7 ordenadas por tiempo no se mantienen en orden.

Cómo generar un UUID en código

La mayoría de los lenguajes crean un UUID v4 en una línea, y muchos ya crean también v7: uuid.uuid7() de Python 3.14, Guid.CreateVersion7() de .NET 9, UUID.ofEpochMillis() de Java 26, uuid.NewV7() de Go 1.27, crypto.randomUUIDv7() de Node.js 26.1 y uuidv7() de PostgreSQL 18. Los navegadores siguen teniendo solo crypto.randomUUID(), un v4.

Elija su lenguaje para ver la línea de código. No todos los v7 mantienen en orden los UUID creados en el mismo milisegundo: los de Python y Go sí; los de .NET y Node no lo garantizan. Y UUID() de MySQL devuelve un UUID versión 1, que en Linux y Windows lleva la dirección MAC real del servidor.

Funciones de UUID integradas, por lenguaje

Python
import uuid

uuid.uuid4()   # v4
uuid.uuid7()   # v7, Python 3.14+
uuid.uuid5(uuid.NAMESPACE_DNS, "www.example.com")  # v5

uuid7() usa un contador de 42 bits, así que los UUID de un mismo milisegundo se mantienen en orden.

Versiones según la documentación de cada lenguaje; los logotipos son los de cada proyecto.

¿Pueden dos UUID ser iguales?

En teoría sí, en la práctica no: un UUID v4 tiene 122 bits aleatorios, unos 5,3 × 10³⁶ valores. Habría que crear unos 103 billones para tener una probabilidad de una entre mil millones de que dos coincidan, y unos 2,7 trillones para llegar a una probabilidad del 50 %.

Es la paradoja del cumpleaños: con n valores aleatorios entre N posibles, la probabilidad de una repetición es de aproximadamente 1 − e^(−n(n−1)/2N). Creando mil millones de UUID por segundo, llegar a una probabilidad del 50 % llevaría unos 86 años. Los duplicados reales vienen de generadores defectuosos: una semilla que no es aleatoria, una máquina virtual clonada con su estado aleatorio o identificadores copiados a mano.

En v7 solo pueden coincidir los UUID creados en el mismo milisegundo, y a esos los distinguen 74 bits aleatorios. El generador de esta página además mantiene un lote en orden dentro de un mismo milisegundo (RFC 9562 §6.2), así que 10 000 a la vez son únicos y están ordenados.

La paradoja del cumpleañosnuestros cálculos
Probabilidad de que dos sean iguales1 entre 1,1 × 1019p ≈ 9,4 × 10−20

A mil millones por segundo, crear esa cantidad lleva 1 segundo.

p ≈ 1 − e^(−n(n−1)/2N), con N = 2¹²² para v4 y 2⁷⁴ por milisegundo para v7. La RFC 9562 no da cifras de colisión: estas son nuestras, de la misma función que usa la página.

Decodificador de UUID: cómo leer la marca de tiempo de un UUID

Pegue un UUID en Decodificar y validar, el decodificador y validador de UUID de arriba: lee la versión y la variante en dos posiciones fijas y luego los campos que define esa versión. Un v7 da el milisegundo en que se creó; un v1 o un v6, la hora con precisión de 100 nanosegundos, además de una secuencia de reloj y un ID de nodo.

Un nodo v1 o v6 con el bit multicast desactivado puede ser la dirección MAC real de la tarjeta de red; busque su fabricante en la consulta de direcciones MAC. Los generadores que respetan la privacidad activan ese bit y usan un nodo aleatorio, como este.

La hora es la que escribió el generador, no una prueba de cuándo se creó el UUID. v4 no contiene hora, solo bits aleatorios, y v3, v5 y v8 contienen hashes: no hay nada que leer, y un hash no se puede revertir para obtener el nombre. Pegue una lista para comprobar hasta 1000 a la vez: líneas no válidas, duplicados y si los UUID basados en tiempo están en orden.

Dos formas de escribir el mismo momentoRFC 9562 · Appendix A
017f22e2-79b0-7cc3-98c4-dc0c0c07398f
  1. unix_ts_ms0x017f22e279b0
  2. ms desde 19701 645 557 742 000
  3. UTC2022-02-22T19:22:22.000Z
c232ab00-9414-11ec-b3c8-9f6bdeced846
  1. time_high · time_mid · time_low1ec 9414 c232ab00
  2. pasos de 100 ns desde 1582-10-15138 648 505 420 000 000
  3. UTC2022-02-22T19:22:22.0000000Z

El mismo momento: los ejemplos de la RFC 9562 se crearon juntos.

Un v7 empieza con los milisegundos desde 1970. Un v1 guarda primero la parte baja de su hora, así que el decodificador vuelve a ordenar las tres partes antes de contar desde el 15 de octubre de 1582.

UUID basados en nombre: v5 y v3

Un UUID v5 es el hash SHA-1 de un UUID de espacio de nombres más un nombre, recortado a 128 bits y con la versión y la variante fijadas; v3 hace lo mismo con MD5. El mismo espacio de nombres y el mismo nombre dan siempre el mismo UUID, en cualquier computadora: elija v5 arriba para usar esta página como generador de UUID v5.

La RFC 9562 define cuatro espacios de nombres: DNS para nombres de dominio, URL, OID y X.500. Así, www.example.com en el espacio de nombres DNS es siempre 2ed6657d-e927-568b-95e1-2665a8aea6a2 como v5. Use UUID basados en nombre para dar un ID estable a algo que ya tiene un nombre único, sin guardar una tabla de correspondencias.

Elija v5 en lugar de v3: MD5 es más débil y la RFC 9562 recomienda v5. Ninguno sirve para ocultar el nombre: cualquiera que pueda adivinarlo puede calcular el mismo UUID. La opción v8 de esta página usa SHA-256 de la misma manera, como el ejemplo de v8 de la propia RFC.

Espacio de nombres + nombre → v5RFC 9562 §5.5
  1. Espacio de nombres6ba7b810-9dad-11d1-80b4-00c04fd430c8DNS · 16 bytes
  2. Nombre"www.example.com"UTF-8 · 15 bytes
  3. Resumen SHA-1, 160 bits2ed6657de927468b55e12665a8aea6a22dee3e35se conservan los primeros 128 bits
  4. El UUID2ed6657d-e927-568b-95e1-2665a8aea6a2dígito de versión 4 → 5 · dígito de variante 5 → 9
  • DNS6ba7b810…
  • URL6ba7b811…
  • OID6ba7b812…
  • X.5006ba7b814…
El propio ejemplo de v5 de la RFC 9562: www.example.com en el espacio de nombres DNS. Cualquier computadora que calcule el hash del mismo espacio de nombres y el mismo nombre obtiene el mismo UUID.

ULID vs UUID v7 (y otros ID)

Un ULID y un UUID v7 empiezan con una marca de tiempo de 48 bits en milisegundos y se ordenan por tiempo. La diferencia: un ULID dedica todos sus otros 80 bits al azar y se escribe como 26 caracteres Base32, mientras que un v7 gasta 6 bits en su versión y su variante, y encaja en cualquier columna y biblioteca de UUID.

Si su base de datos, su ORM o su API ya trabajan con UUID, v7 le da orden temporal sin un tipo nuevo. NanoID y otros ID cortos similares son cadenas aleatorias de la longitud elegida, sin hora ni estructura estándar. Cualquier UUID también se puede escribir más corto: 22 caracteres en Base64url, 22 como máximo en Base58.

Tres ID, 128 bits cada unoa escala
UUID v7hora, luego aleatorio
36 caracteresse ordena por tiempo
ULIDhora, luego aleatorio
26 caracteresse ordena por tiempo
UUID v4solo aleatorio
36 caracteressin orden
  • milisegundos desde 1970
  • aleatorio
  • versión y variante
UUID v7 y ULID comparten el reloj de 48 bits en milisegundos; v7 dedica 6 bits a su versión y su variante, y ULID usa los 80 para el azar. Un v4 es solo aleatorio; en Base64url, cualquier UUID tiene 22 caracteres.

¿Es seguro usar UUID como tokens?

No. La RFC 9562 dice que no se debe suponer que los UUID son difíciles de adivinar, y que nunca se use uno como capacidad de seguridad: un ID cuya sola posesión da acceso, como un enlace para restablecer una contraseña o una clave de API.

Un v4 de un buen generador es aleatorio, pero un v1, v6 o v7 revela su fecha de creación, y un v3 o v5 se puede volver a calcular a partir de su nombre. Para secretos, use un token hecho para eso, como 256 bits aleatorios de un generador criptográfico, y verifique los permisos en cada solicitud. Los UUID sirven como ID públicos cuando el acceso se verifica por separado.

IDLo que puede saber cualquiera que lo veaComo secreto
v1, v6Cuándo se creó, y quizá la dirección MAC de la tarjeta de redNo
v7El milisegundo en que se creóNo
v5, v3Nada nuevo, pero un nombre adivinado da el mismo UUIDNo
v4Nada, si el generador es sólidoNo
Token de 256 bitsNada: está hecho para secretosSí
La RFC 9562 dice que no se debe suponer que los UUID son difíciles de adivinar ni usarlos como capacidades de seguridad. Para los secretos, use un token de un generador criptográfico y verifique el acceso en cada solicitud.

Generador de UUID: preguntas y respuestas

¿Cómo puedo generar un UUID?

Abra esta página: un UUID v4 aleatorio ya está listo para copiar, y Nuevo UUID crea otro. Elija v7 para usarla como generador de UUID v7, indique una cantidad de hasta 10 000 a la vez y elija un formato, como llaves o Base64url. En código, crypto.randomUUID() en JavaScript, uuid.uuid4() en Python y Guid.NewGuid() en C# crean cada uno un v4 en una línea.

¿Qué significa UUID?

Universally Unique Identifier, es decir, identificador único universal. Es un valor de 128 bits, escrito como 36 caracteres, por ejemplo 919108f7-52d1-4320-9bac-f847db4148a8, que las computadoras crean de forma independiente, sin un registro central, y que aun así se espera que sea único. Lo define la RFC 9562. Microsoft llama GUID al mismo valor: Globally Unique Identifier, identificador único global.

¿Un GUID es lo mismo que un UUID?

Sí, a efectos prácticos: los mismos 128 bits y la misma forma de texto, y Guid.NewGuid() crea un UUID estándar versión 4. Hay dos detalles distintos. .NET guarda los tres primeros grupos en little-endian, así que los arrays de bytes sin procesar salen en otro orden, y SQL Server ordena los valores uniqueidentifier empezando por el último grupo. Para generar un GUID online, use esta página como generador de GUID aleatorio: el texto que copie sirve en ambos mundos.

¿Qué versión de UUID debería usar?

La versión 7 para claves de bases de datos y todo lo que se ordena, porque empieza con la fecha de creación y mantiene compactos los índices. La versión 4 cuando el ID no deba revelar cuándo se creó. La versión 5 cuando el mismo nombre deba corresponder siempre al mismo ID. Evite v1 en proyectos nuevos: la RFC 9562 recomienda v7 en su lugar, y un v1 puede llevar una dirección MAC real.

¿Pueden dos UUID llegar a ser iguales?

Solo con una probabilidad astronómicamente pequeña, si el generador es sólido. Un v4 tiene 122 bits aleatorios, así que con unos 103 billones de UUID hay una probabilidad de una entre mil millones de una sola repetición, y para una probabilidad del 50 % hacen falta unos 2,7 trillones. Los duplicados del mundo real vienen de generadores defectuosos, máquinas virtuales clonadas o datos copiados, no de las matemáticas.

¿Se puede decodificar un UUID?

En parte. Todo UUID muestra su versión y su variante. Un v7 revela además el milisegundo en que se creó, y un v1 o v6, la hora con precisión de 100 nanosegundos, una secuencia de reloj y un ID de nodo, a veces una dirección MAC real. Un v4 solo contiene bits aleatorios, y v3 y v5 contienen hashes que no se pueden convertir de vuelta en el nombre. Pegue uno en Decodificar y validar.

¿Qué longitud tiene un UUID?

128 bits, o 16 bytes. Como texto tiene 36 caracteres: 32 dígitos hexadecimales y 4 guiones en grupos de 8-4-4-4-12. Sin guiones tiene 32 caracteres, entre llaves 38, con el prefijo urn:uuid: 45, en Base64url 22 y como entero decimal hasta 39 dígitos. Cuando pueda, guárdelo como tipo UUID nativo o en 16 bytes en lugar de como texto.

¿Qué es un GUID vacío o un UUID Nil?

El valor con los 128 bits en cero: 00000000-0000-0000-0000-000000000000. La RFC 9562 lo llama UUID Nil, y Guid.Empty de .NET es el mismo valor, que suele indicar que no hay ningún ID asignado. La RFC 9562 también define el UUID Max, todo unos, ffffffff-ffff-ffff-ffff-ffffffffffff, como valor centinela (.NET 9: Guid.AllBitsSet). Ninguno es aleatorio, así que nunca los use como ID reales.

¿Se pueden ordenar los UUID v7?

Sí. Sus primeros 48 bits son el tiempo Unix en milisegundos, así que ordenar UUID v7 como texto o como bytes los ordena por fecha de creación, al milisegundo. Dentro de un mismo milisegundo, el orden depende del generador: este mantiene un lote estrictamente creciente, como describe la sección 6.2 de la RFC 9562. El uniqueidentifier de SQL Server es la excepción: compara primero el último grupo.

¿Es seguro usar un UUID como contraseña o token de acceso?

No. La RFC 9562 advierte que no se debe suponer que los UUID son difíciles de adivinar ni usarlos como capacidades de seguridad. Las versiones basadas en tiempo revelan cuándo se crearon, y las basadas en nombre se pueden volver a calcular. Para los secretos, use un token aleatorio de un generador criptográfico, y trate los UUID como ID públicos con el acceso verificado por separado. Para contraseñas, use el generador de contraseñas.

¿Los UUID creados aquí se envían a algún sitio?

No. Se crean en su navegador con crypto.getRandomValues, su generador de números aleatorios criptográficamente seguro, y los UUID pegados se decodifican en su dispositivo. Nada de lo que genere o pegue se envía a nosotros ni a nadie más. Un enlace para compartir lleva solo lo que usted eligió: la versión, la cantidad y el formato, el nombre para v5 o los UUID que pegó en el decodificador, así que compártalo como compartiría esos datos.

¿Le falta algo?Sugiera una función o una herramienta nueva

Herramientas relacionadas