Validador de UUID

Valida UUIDs individuales o listas en lote según RFC 9562 localmente en el navegador.

Sin subidasSin registroResultados instantáneos
RFC 9562 estricto + Filtros de versiónDiagnóstico masivo línea por líneaInforme de auditoría JSON y CSV
Validar UUID
Motor local listoEspacio de trabajo 100% privado en el navegador • Sin subidas a la nube
100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Validador de UUID gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Cobertura Completa de Versiones RFC 9562

Valida identificadores modernos UUIDv6, UUIDv7 y UUIDv8 junto con las versiones clásicas v1 a v5 y los UUIDs especiales Nil (todo ceros) y Max (todo unos) que las expresiones regulares antiguas de RFC 4122 rechazan.

Clasificación y Filtrado en Lote Línea por Línea

Procesa miles de cadenas candidatas separadas por saltos de línea en una sola pasada, etiquetando cada fila con su versión detectada, prefijo de variante y error de sintaxis exacto antes de exportar conjuntos válidos y depurados.

Verificación Estricta de Variante y Sintaxis Canónica

Comprueba la estructura hexadecimal exacta de 36 caracteres (8-4-4-4-12) y distingue los bits de variante estándar de RFC 9562 (10xx) de los GUID heredados de Microsoft COM (110x), NCS (0xxx) y tokens no hexadecimales.

Procesamiento en Lote 100% Local en el Navegador

Ejecuta la verificación de sintaxis, la normalización a minúsculas y el filtrado íntegramente dentro de la pestaña de tu navegador sin subir volcados de bases de datos, IDs de clientes ni extractos de logs a servidores externos.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Cobertura Completa de Versiones RFC 9562 Valida identificadores modernos UUIDv6, UUIDv7 y UUIDv8 junto con las versiones clásicas v1 a v5 y los UUIDs especiales Nil (todo ceros) y Max (todo unos) que las expresiones regulares antiguas de RFC 4122 rechazan. Opciones limitadas sin personalización avanzada
Clasificación y Filtrado en Lote Línea por Línea Procesa miles de cadenas candidatas separadas por saltos de línea en una sola pasada, etiquetando cada fila con su versión detectada, prefijo de variante y error de sintaxis exacto antes de exportar conjuntos válidos y depurados. Requiere herramientas externas o ajustes manuales
Privacidad y Procesamiento 100% local en tu navegador (cero subidas al servidor) Sube los datos a servidores externos en la nube
Precio y Registro 100% gratis para siempre y sin crear cuenta Requiere registro de cuenta o suscripción de pago
Cómo funciona

Cómo usar Validador de UUID en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Pega los UUIDs Candidatos o Sube un Archivo

Introduce un único UUID, pega un lote multilínea de logs de aplicaciones o exportaciones SQL, o arrastra un archivo de texto o CSV local al validador.

2

Revisa Sintaxis, Versión y Variante por Línea

Inspecciona el resumen del lote con el recuento de líneas válidas e inválidas, la clasificación de versión por fila (v1 a v8, Nil, Max) y diagnósticos específicos para las líneas rechazadas.

3

Filtra y Exporta los UUIDs Depurados

Filtra los resultados para obtener identificadores válidos según RFC 9562 o una versión específica de UUID, y luego copia o descarga la lista normalizada en minúsculas.

Guía de Validación de UUIDs en Lote: Listas de Entrada y Diagnóstico

Respuesta rápida: Al validar una lista multilínea de identificadores candidatos, cada fila recortada se comprueba frente a la estructura hexadecimal canónica de 36 caracteres 8-4-4-4-12, se compara primero con las constantes especiales Nil y Max, y luego se evalúa para confirmar que el nibble 13 codifica la versión 1-8 y el nibble 17 comienza con los bits de variante 10xx de RFC 9562.

Los pipelines de datos y los procesos de ingesta de APIs encuentran con frecuencia formatos de identificadores mixtos: claves modernas UUIDv7, GUIDs heredados en mayúsculas, constantes centinela y tokens que no son UUID como los ULIDs. A continuación se muestra un lote concreto de siete líneas que demuestra cómo la validación RFC 9562 clasifica cada caso.

Ejemplo de Entrada Candidata Multilínea

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF
550e8400-e29b-91d4-a716-446655440000
550e8400-e29b-41d4-c716-446655440000
01ARZ3NDEKTSV4RRFFQ69G5FAV

Informe de Clasificación por Fila

[
  {
    "line": 1,
    "input": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f",
    "valid": true,
    "classification": "UUIDv7",
    "variant": "RFC 9562 (10xx)",
    "normalized": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f"
  },
  {
    "line": 2,
    "input": "550e8400-e29b-41d4-a716-446655440000",
    "valid": true,
    "classification": "UUIDv4",
    "variant": "RFC 9562 (10xx)",
    "normalized": "550e8400-e29b-41d4-a716-446655440000"
  },
  {
    "line": 3,
    "input": "00000000-0000-0000-0000-000000000000",
    "valid": true,
    "classification": "Nil UUID (RFC 9562 Section 5.9)",
    "variant": "Nil (all zeros)",
    "normalized": "00000000-0000-0000-0000-000000000000"
  },
  {
    "line": 4,
    "input": "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF",
    "valid": true,
    "classification": "Max UUID (RFC 9562 Section 5.10)",
    "variant": "Max (all ones)",
    "normalized": "ffffffff-ffff-ffff-ffff-ffffffffffff"
  },
  {
    "line": 5,
    "input": "550e8400-e29b-91d4-a716-446655440000",
    "valid": false,
    "error": "Invalid version nibble '9' at position 15 (expected 1-8, or Nil/Max)"
  },
  {
    "line": 6,
    "input": "550e8400-e29b-41d4-c716-446655440000",
    "valid": false,
    "error": "Non-RFC-9562 variant nibble 'c' (110x Microsoft legacy GUID; expected 8, 9, a, or b)"
  },
  {
    "line": 7,
    "input": "01ARZ3NDEKTSV4RRFFQ69G5FAV",
    "valid": false,
    "error": "Invalid length (26 chars, Crockford Base32 ULID pattern; expected 36-char 8-4-4-4-12 hex)"
  }
]

Exportación Canónica Filtrada

Al exportar las filas válidas, los caracteres hexadecimales en mayúsculas se normalizan a minúsculas canónicas según la Sección 4 de RFC 9562:

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
ffffffff-ffff-ffff-ffff-ffffffffffff

Reglas de Validación RFC 9562, Casos Límite de Regex y Normalización Canónica

Respuesta rápida: Un validador compatible con RFC 9562 no puede depender de las expresiones regulares heredadas de RFC 4122 [1-5]: debe aceptar las versiones 1 a 8 combinadas con la variante [89ab], permitir explícitamente el Nil UUID (todo ceros) y el Max UUID (todo unos), y normalizar los dígitos hexadecimales en mayúsculas a minúsculas canónicas antes del almacenamiento indexado por cadenas.

El estándar RFC 9562 (mayo de 2024) amplió la especificación de UUID de cinco a ocho versiones y formalizó dos constantes límite, dejando obsoletos los patrones de validación antiguos que aún están integrados en muchas librerías de validación y API gateways.

Por Qué las Expresiones Regulares Heredadas de RFC 4122 Fallan con Claves Modernas

Los validadores anteriores a 2024 suelen exigir [1-5] en el 13.º dígito hexadecimal y omiten los valores centinela, rechazando claves válidas de tipo UUIDv6, UUIDv7, UUIDv8, Nil y Max. Una expresión regular completa e insensible a mayúsculas/minúsculas según RFC 9562 que coincide con la sintaxis canónica 8-4-4-4-12 para v1-v8 además de Nil y Max es:

^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$

Al validar entradas no confiables en entornos de backend como Python, Ruby o PCRE, ancla el final de la cadena con \z (o \Z en re.fullmatch de Python) en lugar de $, ya que $ coincide inmediatamente antes de un carácter de salto de línea \n final y puede permitir que payloads con inyección de saltos de línea superen comprobaciones de cadenas simples.

Tipos `uuid` en Bases de Datos vs Esquemas de Aplicación Estrictos

Una causa frecuente de fallos de ingesta en producción es la discrepancia entre los analizadores permisivos de bases de datos y los validadores estrictos de esquemas de API:

  • Analizadores Hexadecimales Permisivos de 128 Bits (p. ej., uuid en PostgreSQL): PostgreSQL acepta cualesquiera 32 dígitos hexadecimales (con guiones canónicos, llaves {...} opcionales o sin guiones) independientemente del nibble de versión (0-f) o del prefijo de variante (0xxx, 10xx, 110x, 111x). Los GUIDs heredados de Microsoft COM (variante 110x, hex c o d en el dígito 17) o hashes MD5 arbitrarios de 128 bits almacenados en una columna uuid superan los inserts SQL sin error.
  • Validadores Estrictos de RFC 9562 (OpenAPI, Zod, crate uuid de Rust, google/uuid de Go): Los esquemas estrictos de API verifican el formato canónico de 36 caracteres con guiones y suelen exigir la variante 10xx y las versiones 1-8 (más Nil/Max). Validar las exportaciones SQL en lote antes de enviarlas a servicios REST o gRPC estrictos permite detectar a tiempo filas con variantes fuera del RFC.

Normalización Canónica a Minúsculas

La Sección 4 de RFC 9562 exige que los analizadores acepten mayúsculas A-F en la entrada pero produzcan minúsculas a-f en la salida. Los tipos binarios nativos de 16 bytes en bases de datos (UUID en PostgreSQL, BINARY(16) en MySQL) eliminan la distinción entre mayúsculas y minúsculas automáticamente, pero los sistemas que almacenan UUIDs en VARCHAR(36), claves de Redis, claves de partición de DynamoDB o cachés JSON tratan 550E8400-... y 550e8400-... como cadenas distintas a menos que se normalicen a minúsculas durante la validación.

Validador de UUID vs Analizador de UUID vs Generador de UUID: ¿Cuál Necesitas?

Respuesta rápida: Usa el Validador de UUID para verificar la sintaxis, comprobar el cumplimiento de RFC 9562, clasificar versiones en listas masivas y exportar IDs limpios. Usa el Analizador y Decodificador de UUID para extraer marcas de tiempo UTC incrustadas y campos de 128 bits de un UUID específico, o el Generador de UUID v4 para crear nuevos identificadores criptográficamente aleatorios.

Elige la herramienta de UUID de Utiliome adecuada según necesites auditar listas existentes, inspeccionar campos de bits internos o generar claves nuevas:

Capacidad Validador de UUID (Esta Herramienta) Analizador y Decodificador de UUID Generador de UUID v4
Propósito Principal Validar lotes de UUIDs individuales o multilínea y filtrar entradas mal formadas Decodificar la estructura binaria de 128 bits, ID de nodo y marca de tiempo UTC incrustada de un UUID Generar en lote identificadores UUIDv4 criptográficamente aleatorios (CSPRNG)
Procesamiento de Listas en Lote Sí — pega listas o sube archivos, consulta diagnósticos por línea y exporta conjuntos válidos No — diseñado para la inspección profunda de campos de bits de identificadores individuales Genera lotes nuevos de claves v4 aleatorias; no valida entradas externas
Cobertura de Versiones Clasifica de v1 a v8, Nil (0000...) y Max (ffff...) Decodifica estructuras de bits de v1 a v8, Nil y Max Genera exclusivamente UUIDv4 según RFC 9562 (usa el Generador de UUID v7, v6 y v1 para claves ordenadas por tiempo)
Extracción de Timestamp Identifica si una clave está basada en tiempo (v1, v6, v7) sin decodificar fechas Extrae fechas UTC exactas en ISO-8601, milisegundos Unix y ticks gregorianos de 100 ns No aplica (UUIDv4 contiene 122 bits aleatorios y ningún dato de marca de tiempo)

Flujos de Trabajo Recomendados para Desarrolladores

  • Limpieza de exportaciones CSV, logs o payloads de migración: Pega tu lista aquí para separar los identificadores válidos según RFC 9562 de cadenas corruptas, ULIDs o GUIDs heredados fuera del RFC, y exporta una lista limpia en minúsculas.
  • Investigar cuándo se creó una clave basada en tiempo: Copia cualquier identificador válido v1, v6 o v7 en el Analizador y Decodificador de UUID para inspeccionar su marca de tiempo de creación UTC incrustada, secuencia de reloj y campos binarios de 128 bits.
  • Generar nuevos identificadores: Utiliza el Generador de UUID v4 para obtener tokens aleatorios impredecibles, o el Generador de UUID v7, v6 y v1 para claves primarias de bases de datos ordenables cronológicamente.
Preguntas frecuentes

Preguntas frecuentes y guía técnica de Validador de UUID

Todo lo que necesitas saber sobre el uso gratuito en línea de validador de uuid en Utiliome.

¿Son válidos los UUID Nil (todo ceros) y Max (todo Fs) según RFC 9562?

Sí. La Sección 5.9 de RFC 9562 define 00000000-0000-0000-0000-000000000000 como el Nil UUID, y la Sección 5.10 define ffffffff-ffff-ffff-ffff-ffffffffffff como el Max UUID para valores centinela y consultas de rango de límite superior, aunque sus nibbles de versión y variante estén fuera de [1-8] y [89ab].

¿Por qué un GUID de Microsoft se inserta bien en PostgreSQL pero falla en la validación estricta de RFC 9562?

Los GUID heredados de Microsoft COM/DCOM pueden llevar la variante de retrocompatibilidad 110x (c o d hexadecimal en el 17.º dígito hex) en lugar de la variante 10xx de RFC 9562 (8, 9, a, b). El tipo de columna nativo uuid de PostgreSQL acepta cualquier valor hexadecimal de 128 bits sin comprobar los bits de versión o variante, mientras que los validadores estrictos de RFC 9562 rechazan las variantes que no sean 10xx.

¿El formato hexadecimal en mayúsculas hace que un UUID sea inválido?

No. La Sección 4 de RFC 9562 establece que los analizadores deben aceptar tanto mayúsculas A-F como minúsculas a-f de forma insensible a mayúsculas/minúsculas al leer UUIDs, pero exige que los generadores y formateadores produzcan texto hexadecimal en minúsculas canónicas para que los índices de cadenas y mapas hash sensibles a mayúsculas no almacenen claves duplicadas.

¿Por qué las expresiones regulares antiguas de validación de UUID rechazan UUID v7 y UUID v8?

Los patrones regex escritos para RFC 4122 (publicado en 2005) fijan [1-5] en el 13.º dígito hexadecimal porque solo existían las versiones 1 a 5 antes de mayo de 2024, cuando el estándar RFC 9562 estandarizó la versión gregoriana reordenada v6, la versión ordenada por tiempo Unix Epoch v7, la versión personalizada v8 y el Max UUID compuesto por todos unos.

¿Son válidos como UUIDs canónicos los ULIDs, los GUIDs entre llaves o las cadenas hexadecimales de 32 caracteres sin guiones?

No en su forma textual canónica. Los ULIDs codifican 128 bits como 26 caracteres en Crockford Base32 en lugar de hexadecimal, mientras que las llaves {...}, los prefijos urn:uuid: y las cadenas de 32 caracteres sin guiones son envoltorios de transporte alternativos; la sintaxis canónica de UUID en RFC 9562 exige estrictamente 36 caracteres formateados como dígitos hexadecimales 8-4-4-4-12.