Validador de UUID

Valide UUIDs únicos ou listas em lote conforme a RFC 9562 localmente no navegador.

Sem uploadsSem cadastroResultados instantâneos
RFC 9562 Estrito + Filtros de VersãoDiagnóstico Linha a Linha em LoteRelatório de Auditoria JSON e CSV
Validar UUIDs
Motor offline prontoEspaço de trabalho 100% privado no navegador • Sem uploads para a nuvem
100% Privado • Sem Upload de Arquivos para Servidor

Por que usar o Validador de UUID gratuito do Utiliome?

Criado do zero para privacidade estrita, execução instantânea e sem atrito. Sem assinaturas, paywalls ou cadastro.

Cobertura Completa de Versões da RFC 9562

Valida identificadores modernos UUIDv6, UUIDv7 e UUIDv8 junto com as chaves clássicas v1 a v5 e os UUIDs especiais Nil (todos zeros) e Max (todos uns) que expressões regulares legadas da RFC 4122 rejeitam.

Classificação e Filtragem em Lote Linha por Linha

Processa milhares de strings candidatas separadas por quebra de linha de uma só vez, marcando cada linha com a versão detectada, prefixo de variante e erro exato de sintaxe antes de exportar conjuntos válidos e higienizados.

Verificação Estrita de Variante e Sintaxe Canônica

Verifica a estrutura hexadecimal exata de 36 caracteres (8-4-4-4-12) e diferencia os bits de variante padrão da RFC 9562 (10xx) de GUIDs legados da Microsoft COM (110x), NCS (0xxx) e tokens não hexadecimais.

Processamento em Lote 100% Local no Navegador

Executa a verificação de sintaxe, normalização para minúsculas e filtragem inteiramente na aba do seu navegador, sem enviar dumps de banco de dados, IDs de clientes ou trechos de logs para servidores externos.

Utiliome vs Alternativas Tradicionais em Nuvem

Compare nosso motor WebAssembly local contra ferramentas de nuvem legadas.

Recurso Utiliome (Navegador Local) Conversores de Nuvem Legados
Cobertura Completa de Versões da RFC 9562 Valida identificadores modernos UUIDv6, UUIDv7 e UUIDv8 junto com as chaves clássicas v1 a v5 e os UUIDs especiais Nil (todos zeros) e Max (todos uns) que expressões regulares legadas da RFC 4122 rejeitam. Opções limitadas sem personalização avançada
Classificação e Filtragem em Lote Linha por Linha Processa milhares de strings candidatas separadas por quebra de linha de uma só vez, marcando cada linha com a versão detectada, prefixo de variante e erro exato de sintaxe antes de exportar conjuntos válidos e higienizados. Requer ferramentas externas ou ajuste manual
Privacidade e Processamento 100% local no navegador (zero upload para servidor) Envia os dados para servidores externos na nuvem
Preço e Cadastro 100% gratuito para sempre e sem criar conta Exige cadastro de conta ou assinatura paga
Como funciona

Como usar o Validador de UUID em 3 passos simples

Nenhuma instalação necessária. Tudo roda diretamente dentro do seu navegador.

1

Cole os UUIDs Candidatos ou Envie um Arquivo

Digite um único UUID, cole um lote de várias linhas vindo de logs de aplicações ou exportações SQL, ou arraste um arquivo local de texto ou CSV para o validador.

2

Revise Sintaxe, Versão e Variante por Linha

Inspecione o resumo do lote exibindo a contagem de linhas válidas vs. inválidas, a classificação de versão por linha (v1 a v8, Nil, Max) e diagnósticos específicos para as linhas rejeitadas.

3

Filtre e Exporte os UUIDs Higienizados

Filtre os resultados para manter apenas identificadores válidos na RFC 9562 ou uma versão específica de UUID e, em seguida, copie ou baixe a lista normalizada em letras minúsculas.

Passo a Passo da Validação de UUID em Lote: Listas de Entrada e Diagnóstico

Resposta Rápida: Ao validar uma lista de várias linhas de identificadores candidatos, cada linha sem espaços extras é testada contra a estrutura hexadecimal canônica de 36 caracteres 8-4-4-4-12, comparada primeiro com as constantes especiais Nil e Max e, em seguida, verificada para confirmar se o nibble 13 codifica a versão 1-8 e o nibble 17 começa com os bits de variante 10xx da RFC 9562.

Pipelines de dados e rotinas de ingestão de APIs frequentemente encontram formatos mistos de identificadores — chaves UUIDv7 modernas, GUIDs legados em maiúsculas, constantes sentinelas e tokens que não são UUID, como ULIDs. Abaixo está um lote prático de sete linhas demonstrando como a validação pela RFC 9562 classifica cada caso.

Exemplo de Entrada Candidata de Várias Linhas

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

Relatório de Classificação por Linha

[
  {
    "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)"
  }
]

Exportação Canônica Filtrada

A exportação das linhas válidas normaliza caracteres hexadecimais maiúsculos para o formato canônico em minúsculas, conforme a Seção 4 da RFC 9562:

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

Regras de Validação da RFC 9562, Casos Extremos de Regex e Normalização Canônica

Resposta Rápida: Um validador compatível com a RFC 9562 não pode depender de expressões regulares legadas da RFC 4122 [1-5]: ele deve aceitar as versões 1 a 8 combinadas com a variante [89ab], liberar explicitamente o Nil UUID (todos zeros) e o Max UUID (todos uns) e normalizar dígitos hexadecimais maiúsculos para minúsculas canônicas antes do armazenamento indexado por string.

A RFC 9562 (maio de 2024) expandiu a especificação de UUID de cinco para oito versões e formalizou duas constantes de limite, quebrando padrões de validação antigos que ainda estão embutidos em muitas bibliotecas de validação e API gateways.

Por Que Expressões Regulares Legadas da RFC 4122 Falham em Chaves Modernas

Validadores anteriores a 2024 geralmente exigem [1-5] no 13º dígito hexadecimal e omitem valores sentinelas, rejeitando chaves válidas UUIDv6, UUIDv7, UUIDv8, Nil e Max. Uma expressão regular completa e case-insensitive da RFC 9562 que valida a sintaxe canônica 8-4-4-4-12 para v1-v8 além de Nil e Max é:

^(?:[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})$

Ao validar entradas não confiáveis em runtimes de backend como Python, Ruby ou PCRE, ancore o final da string com \z (ou \Z em re.fullmatch do Python) em vez de $, pois $ corresponde imediatamente antes de uma quebra de linha \n no final e pode permitir que payloads com injeção de quebra de linha passem por verificações simples de string.

Tipos `uuid` de Banco de Dados vs Schemas Estritos de Aplicação

Uma fonte frequente de falhas de ingestão em produção é a diferença entre parsers tolerantes de bancos de dados e validadores estritos de schemas de API:

  • Parsers Hexadecimais Tolerantes de 128 Bits (ex.: uuid no PostgreSQL): O PostgreSQL aceita quaisquer 32 dígitos hexadecimais (com hifens canônicos, chaves {...} opcionais ou sem hifens), independentemente do nibble de versão (0-f) ou prefixo de variante (0xxx, 10xx, 110x, 111x). GUIDs legados do Microsoft COM (variante 110x, hex c ou d no dígito 17) ou hashes MD5 arbitrários de 128 bits armazenados em uma coluna uuid passam por inserts SQL sem erro.
  • Validadores Estritos da RFC 9562 (OpenAPI, Zod, crate uuid do Rust, google/uuid do Go): Schemas estritos de API verificam a hifenização canônica de 36 caracteres e costumam exigir a variante 10xx e as versões 1-8 (além de Nil/Max). Validar exportações SQL em lote antes de reprocessá-las em serviços REST ou gRPC estritos captura linhas com variantes fora da RFC antecipadamente.

Normalização Canônica de Maiúsculas e Minúsculas

A Seção 4 da RFC 9562 determina que os parsers aceitem letras maiúsculas A-F na entrada, mas gerem letras minúsculas a-f na saída. Tipos binários nativos de 16 bytes em bancos de dados (UUID no PostgreSQL, BINARY(16) no MySQL) eliminam a diferença de caixa automaticamente, mas sistemas que armazenam UUIDs em VARCHAR(36), chaves do Redis, chaves de partição do DynamoDB ou caches JSON tratam 550E8400-... e 550e8400-... como strings distintas, a menos que sejam normalizadas para minúsculas durante a validação.

Validador de UUID vs Analisador de UUID vs Gerador de UUID: Qual Usar?

Resposta Rápida: Use o Validador de UUID para verificar a sintaxe, checar a conformidade com a RFC 9562, classificar versões em listas em lote e exportar IDs limpos. Use o Analisador e Decodificador de UUID para extrair timestamps UTC embutidos e campos de 128 bits de um UUID específico, ou o Gerador de UUID v4 para criar novos identificadores criptograficamente aleatórios.

Escolha o utilitário de UUID da Utiliome ideal dependendo se você está auditando listas existentes, inspecionando campos internos de bits ou gerando novas chaves:

Recurso Validador de UUID (Esta Ferramenta) Analisador e Decodificador de UUID Gerador de UUID v4
Objetivo Principal Validar lotes de UUIDs únicos ou de várias linhas e filtrar entradas malformadas Decodificar o layout binário de 128 bits, ID de nó e timestamp UTC embutido de um UUID Gerar em lote identificadores UUIDv4 criptograficamente aleatórios (CSPRNG)
Processamento em Lote Sim — cole listas ou envie arquivos, veja diagnósticos por linha e exporte conjuntos válidos Não — projetado para inspeção profunda de campos de bits de identificadores individuais Gera novos lotes de chaves v4 aleatórias; não valida entradas externas
Cobertura de Versões Classifica v1 até v8, Nil (0000...) e Max (ffff...) Decodifica estruturas de bits para v1 até v8, Nil e Max Gera exclusivamente UUIDv4 padrão RFC 9562 (use o Gerador de UUID v7, v6 e v1 para chaves ordenadas por tempo)
Extração de Timestamp Identifica se uma chave é baseada em tempo (v1, v6, v7) sem decodificar datas Extrai datas UTC exatas em ISO-8601, ms Unix e ticks gregorianos de 100 ns Não aplicável (o UUIDv4 contém 122 bits aleatórios e nenhum dado de timestamp)

Fluxos de Trabalho Recomendados para Desenvolvedores

  • Higienização de exportações CSV, logs ou payloads de migração: Cole sua lista aqui para separar identificadores válidos pela RFC 9562 de strings corrompidas, ULIDs ou GUIDs legados fora do padrão RFC, exportando uma lista limpa em minúsculas.
  • Investigação de quando uma chave baseada em tempo foi gerada: Copie qualquer identificador válido v1, v6 ou v7 para o Analisador e Decodificador de UUID para inspecionar seu timestamp UTC de criação embutido, sequência de clock e campos binários de 128 bits.
  • Geração de novos identificadores: Use o Gerador de UUID v4 para tokens aleatórios imprevisíveis, ou o Gerador de UUID v7, v6 e v1 para chaves primárias de banco de dados ordenáveis cronologicamente.
Perguntas frequentes

FAQ e Guia Técnico do Validador de UUID

Tudo o que você precisa saber sobre o validador de uuid online e gratuito do Utiliome.

Os UUIDs Nil (todos zeros) e Max (todos Fs) são válidos segundo a RFC 9562?

Sim. A Seção 5.9 da RFC 9562 define 00000000-0000-0000-0000-000000000000 como o Nil UUID, e a Seção 5.10 define ffffffff-ffff-ffff-ffff-ffffffffffff como o Max UUID para valores sentinelas e consultas de limite superior em intervalos, mesmo que seus nibbles de versão e variante fiquem fora de [1-8] e [89ab].

Por que um GUID da Microsoft funciona no PostgreSQL, mas falha na validação estrita da RFC 9562?

GUIDs legados do Microsoft COM/DCOM podem trazer a variante de retrocompatibilidade 110x (hex c ou d no 17º dígito hexadecimal) em vez da variante 10xx da RFC 9562 (8, 9, a, b). O tipo nativo de coluna uuid do PostgreSQL aceita qualquer valor hexadecimal de 128 bits sem verificar os bits de versão ou variante, enquanto validadores estritos da RFC 9562 sinalizam variantes diferentes de 10xx.

Letras hexadecimais maiúsculas tornam um UUID inválido?

Não. A Seção 4 da RFC 9562 estabelece que os parsers devem aceitar maiúsculas A-F e minúsculas a-f sem diferenciar caixa ao ler UUIDs, mas exige que geradores e formatadores produzam saída hexadecimal canônica em letras minúsculas para que índices de string e mapas hash case-sensitive não armazenem chaves duplicadas.

Por que expressões regulares antigas de validação de UUID rejeitam UUID v7 e UUID v8?

Padrões de regex escritos para a RFC 4122 (publicada em 2005) fixam [1-5] no 13º dígito hexadecimal porque apenas as versões 1 a 5 existiam antes de maio de 2024, quando a RFC 9562 padronizou a versão gregoriana reordenada v6, a versão ordenada por tempo Unix Epoch v7, a versão customizada v8 e o Max UUID composto apenas por bits um.

ULIDs, GUIDs entre chaves ou strings hexadecimais de 32 caracteres sem hifens são UUIDs canônicos válidos?

Não na forma textual canônica. ULIDs codificam 128 bits como 26 caracteres Crockford Base32 em vez de hexadecimal, enquanto chaves {...}, prefixos urn:uuid: e strings de 32 caracteres sem hifens são invólucros alternativos de transporte; a sintaxe canônica de UUID na RFC 9562 exige estritamente 36 caracteres formatados como dígitos hexadecimais 8-4-4-4-12.