Escolha geração ou inspeção
Exemplo fixo
12816 × 8Use Gerar UUIDs quando precisar de novos valores v4 ou v7. Use Validar e inspecionar quando tiver um identificador existente e precisar de sua forma canônica, variante, versão ou timestamp UTC v7.
Gere UUID v4 ou v7 com aleatoriedade segura do navegador. Inspecione estrutura e horário v7 e exporte texto, CSV, JSON ou valores SQL.
Gere UUID v4 ou v7 com aleatoriedade segura do navegador. Inspecione estrutura e horário v7 e exporte texto, CSV, JSON ou valores SQL.
Exemplo fixo
12816 × 8Use Gerar UUIDs quando precisar de novos valores v4 ou v7. Use Validar e inspecionar quando tiver um identificador existente e precisar de sua forma canônica, variante, versão ou timestamp UTC v7.
Exemplo fixo
8 - 4 - 4 - 4 - 12550e8400-e29b-41d4-a716-446655440000Para geração, escolha v4 ou v7, informe uma quantidade inteira de 1 a 1.000 e selecione o formato de texto, a codificação e a apresentação esperados pelo destino.
Exemplo fixo
v4: 122v7: 48 + 74Copie ou baixe a saída visível após a geração. Trate a validação como inspeção estrutural: ela não prova de onde veio um identificador, se ele é secreto ou se existe um registro de banco de dados.
Para preparar três recursos fictícios de API, escolha UUID v4, quantidade 3, Minúsculas, Texto simples e Array JSON, depois Gerar UUIDs. O resultado é um array de três strings, não três objetos com uma propriedade id. Acrescente no código os outros campos necessários aos dados de teste. Mudar a apresentação para Um por linha permite revisar os mesmos valores sem gerar substitutos; Baixar então usa a extensão da apresentação selecionada. Registre a versão gerada separadamente se o dado de teste precisa de proveniência. Uma contagem de três valores únicos confere apenas este lote, não chaves existentes em um banco de dados.
Para uma investigação de log, selecione Validar e inspecionar e cole o exemplo v7 fixo 017f22e2-79b0-7cc3-98c4-dc0c0c07398f. Seu campo de horário é lido como 2022-02-22T19:22:22.000Z, em UTC, independentemente do seu fuso de exibição local. Compare essa pista com um horário de evento registrado de forma independente; o identificador pode ter sido copiado ou gerado com um relógio errado. Copiar no modo de inspeção retorna o UUID canônico em si, não um relatório de investigação com o timestamp decodificado. Registre o horário e sua incerteza nas suas próprias notas se isso importar para a comparação.
Comece com um valor de teste e o contrato documentado do sistema receptor. Um campo de texto UUID pode esperar Minúsculas e Texto simples; um campo de intercâmbio binário pode esperar Base64 de 16 bytes. Mudar essas opções reformata o mesmo lote, então você pode comparar representações sem alterar os próprios identificadores. Confirme que a decodificação reproduz o UUID original antes de importar um conjunto maior. Em CSV, esta ferramenta coloca valores em uma linha, não em um arquivo de uma coluna. Para SQL, ela fornece uma lista de strings entre aspas, não um INSERT executável nem uma conversão binária específica de banco de dados.

GUID e UUID são usados aqui como nomes práticos para a mesma família de identificadores de 128 bits. RFC 9562 define o layout de 16 octetos, o campo de versão, o campo de variante e a forma textual padrão 8-4-4-4-12. ClockTools gera apenas UUID v4 e UUID v7, enquanto o inspetor consegue identificar versões aceitas da variante RFC 1 a 8, além dos valores sentinela nulo e máximo.
A geração é deliberada. Nada é gerado ao abrir a página. Mudar Versão ou Quantidade prepara o próximo lote; não altera as identidades já exibidas. Formato de texto, codificação e apresentação reformata imediatamente os valores existentes sem gerar substitutos. O painel de resultado mantém a contagem e a versão do lote que realmente produziu aqueles valores, então selecionar v7 depois de gerar v4 não reclassifica o lote antigo como v7.
Esta ferramenta usa aleatoriedade criptográfica do navegador para todo UUID gerado e não tem alternativa aleatória fraca. Se Web Crypto estiver indisponível ou devolver duplicatas repetidamente na janela limitada de tentativas, nenhum lote parcial é mantido. Essa falha é útil porque uma alternativa silenciosa faria o resultado parecer mais forte do que é.
8 - 4 - 4 - 4 - 12550e8400-e29b-41d4-a716-446655440000UUID v4 é a opção aleatória de uso geral. Depois que os bits obrigatórios de versão e variante são definidos, restam 122 bits aleatórios. É um bom padrão para clientes independentes, dados de teste, identificadores públicos de recursos e sistemas que não precisam que o próprio identificador revele um horário.
UUID v7 coloca um timestamp Unix em milissegundos nos 48 bits mais significativos e, nesta implementação, usa bits aleatórios para o espaço variável restante. Isso faz valores de milissegundos diferentes ordenarem aproximadamente por criação quando os relógios avançam, o que pode ajudar na revisão de logs e em alguns padrões de índice.
A versão 7 não é uma promessa de ordem estrita de geração. Este gerador não acrescenta contador monotônico nem sequência submilissegundo. Valores criados no mesmo milissegundo contêm bits finais aleatórios, e um relógio de dispositivo que retrocede pode romper a ordenação visível.
| Escolha | O que ClockTools gera | Útil quando | Limite importante |
|---|---|---|---|
| UUID v4 | Variante RFC com versão 4 e 122 bits aleatórios | Identificadores aleatórios independentes, dados de teste, recursos de API e linhas de banco de dados | A ordenação é aleatória e não carrega horário de criação. |
| UUID v7 | Variante RFC com timestamp Unix de 48 bits em milissegundos e bits restantes aleatórios | Agrupamento temporal aproximado para logs, eventos e ordem de inserção | Sem contador monotônico; problemas no relógio do dispositivo afetam a ordenação. |
| Validar e inspecionar | Nenhum identificador novo é gerado | Conferir forma canônica, variante, versão, nulo/máximo ou horário UTC v7 | Estrutura não é proveniência, propriedade, unicidade ou segredo. |
A forma familiar com hífens é uma apresentação textual de 16 bytes. Os cinco grupos têm 8, 4, 4, 4 e 12 dígitos hexadecimais, mas os grupos não são strings aleatórias separadas. O nibble de versão aparece no começo do terceiro grupo, e a variante RFC aparece no primeiro dígito hexadecimal do quarto grupo.
O exemplo v4 público fixo 550e8400-e29b-41d4-a716-446655440000 tem 4 na posição de versão e a na posição de variante RFC. O dígito de variante pode ser 8, 9, a ou b para a variante RFC porque os bits iniciais são 10. Essas posições explicam como a inspeção reconhece campos; elas não revelam se os outros bits foram gerados aleatoriamente. Um valor escrito à mão pode imitar o mesmo padrão.
O inspetor também reconhece valores nulo e máximo como sentinelas especiais. Nulo são todos os bits zero; máximo são todos os bits um. Eles podem ter significado estrutural em um protocolo, mas não são identificadores aleatórios gerados e não devem ser confundidos com valores únicos comuns.
| Parte | Exemplo | Significado |
|---|---|---|
| Grupos canônicos | 550e8400-e29b-41d4-a716-446655440000 | Cinco grupos na forma hexadecimal 8-4-4-4-12. |
| Nibble de versão | 41d4 começa com 4 | Versão 4 neste exemplo. |
| Nibble de variante | a716 começa com a | Variante RFC porque a é um de 8, 9, a ou b. |
| UUID nulo | 00000000-0000-0000-0000-000000000000 | Sentinela reservado de todos zeros, não saída aleatória. |
| UUID máximo | ffffffff-ffff-ffff-ffff-ffffffffffff | Sentinela reservado de todos uns, não saída aleatória. |
Para UUID v7, ClockTools pega um timestamp de milissegundo do relógio do dispositivo para o lote e o grava nos seis primeiros bytes de cada valor. Cada valor ainda recebe bytes aleatórios novos antes que os bits de versão e variante sejam definidos. Se o valor do relógio estiver fora do intervalo do campo de timestamp v7 de 48 bits, ele é rejeitado e a geração falha, sem truncar o timestamp.
A contagem única é local ao lote gerado atual. O gerador usa um Set e tentativas limitadas para que saídas aleatórias duplicadas dentro do lote solicitado não sejam retornadas. Ele não consulta um registro global, um banco de dados, outra aba ou valores produzidos ontem.
Probabilidade ainda não é o mesmo que uma regra de negócio. Se chaves duplicadas teriam consequência, imponha unicidade onde os identificadores são armazenados e trate erros de conflito ali. A geração não consegue conhecer o estado da sua aplicação. Uma nova geração com falha limpa o lote anterior em vez de deixar um resultado antigo parecendo uma nova solicitação bem-sucedida, então copie os dados de teste necessários antes de experimentar o próximo lote.
| Declaração | Coberto | Não coberto |
|---|---|---|
| Únicos neste lote | Os valores gerados visíveis são distintos entre si. | Nenhuma conferência contra seu banco de dados ou outros usuários. |
| Bits aleatórios v4 | 122 bits aleatórios após posicionar versão e variante. | Nenhuma afirmação de que o valor é secreto ou imprevisível o bastante para um fluxo de token. |
| Timestamp v7 | Um milissegundo UTC decodificado dos primeiros 48 bits. | Nenhuma prova de que o relógio do criador era preciso ou honesto. |
| Sem alternativa fraca | A geração para quando Web Crypto está indisponível. | Nenhuma garantia de que toda fonte de entropia de navegador/dispositivo tenha qualidade idêntica. |
Os controles de saída mudam a apresentação, não o identificador subjacente. Minúsculas, maiúsculas, chaves, aspas, sem hífens e URN são formatos de texto para o mesmo valor UUID. Codificação e apresentação são escolhas separadas, então escolha-as conforme o sistema receptor em vez de tratar a saída mais longa ou mais compacta como automaticamente melhor.
A especificação Web Crypto descreve getRandomValues como fonte de valores aleatórios criptograficamente fortes, e esta página depende dessa API do navegador para geração. A formatação acontece depois na página: Base64 codifica os 16 bytes do UUID, Base64 URL usa o alfabeto seguro para URL, e a saída com codificação URL codifica percentualmente a representação textual escolhida.
A validação é inspeção estrutural. Ela aceita 32 dígitos hexadecimais ou a forma exata com hífens 8-4-4-4-12, opcionalmente envolta ou prefixada como URN. Ela informa forma canônica, variante, versão e horário v7 quando os campos sustentam essa leitura. Ela não prova aleatoriedade, origem, autorização, existência em banco de dados ou uso seguro como credencial.
Formato de texto é útil quando o receptor espera um UUID impresso. Minúsculas é a saída canônica do navegador usada pelo gerador, maiúsculas é para sistemas com essa convenção, chaves e aspas são envoltórios, sem hífens é a forma compacta de 32 hexadecimais, e URN acrescenta o prefixo urn:uuid:.
Codificação é outra camada. Texto simples preserva o formato de texto selecionado. Saída com codificação URL codifica esse texto percentualmente. Base64 e Base64 URL ignoram o envoltório de formato de texto e codificam os 16 bytes brutos em ordem de rede; o seletor de formato é desativado para essas codificações porque chaves ou letras maiúsculas não fazem parte do valor em bytes.
Apresentação decide como vários valores são organizados. Um por linha é o mais fácil de revisar. CSV cria uma linha de campos separados por vírgulas. Array JSON é útil para dados de teste e código. Valores SQL cria valores entre aspas separados por vírgulas; é uma lista de valores, não uma instrução SQL completa.
| Controle | Escolha | Consequência de saída |
|---|---|---|
| Formato de texto | Minúsculas | Texto minúsculo com hífens, como 550e8400-e29b-41d4-a716-446655440000. |
| Formato de texto | Maiúsculas | Mesmo identificador com A-F em maiúsculas para sistemas que exigem essa apresentação. |
| Formato de texto | Chaves | Envolve o texto como {550e8400-e29b-41d4-a716-446655440000}. |
| Formato de texto | Entre aspas | Envolve cada valor em aspas duplas antes do tratamento de apresentação. |
| Formato de texto | Sem hífens | Produz 32 dígitos hexadecimais para campos compactos. |
| Formato de texto | URN | Acrescenta urn:uuid: antes do texto UUID canônico. |
| Codificação | Texto simples | Usa exatamente o formato de texto selecionado. |
| Codificação | Base64 | Codifica os 16 bytes, por exemplo VQ6EAOKbQdSnFkRmVUQAAA==. |
| Codificação | Base64 URL | Usa caracteres Base64 seguros para URL e remove o preenchimento, por exemplo VQ6EAOKbQdSnFkRmVUQAAA. |
| Codificação | Codificação URL | Codifica percentualmente o formato de texto selecionado para contextos de URL/query. |
| Apresentação | Um por linha | Escreve cada valor formatado em sua própria linha. |
| Apresentação | CSV | Escreve uma linha CSV; aspas são escapadas pelo serializador CSV. |
| Apresentação | Array JSON | Escreve um array JSON de strings com indentação. |
| Apresentação | Valores SQL | Escreve valores entre aspas separados por vírgulas, não uma instrução INSERT executável. |
Para o UUID fixo 550e8400-e29b-41d4-a716-446655440000, as codificações de bytes são VQ6EAOKbQdSnFkRmVUQAAA== em Base64 e VQ6EAOKbQdSnFkRmVUQAAA em Base64 URL. O texto comum tem 36 caracteres, o hexadecimal compacto tem 32, Base64 com preenchimento tem 24, e esta forma Base64 URL sem preenchimento tem 22. Eles representam os mesmos 16 bytes. Codificar os 36 caracteres ASCII impressos em vez disso codificaria outra entrada e não produziria esses resultados de bytes.
RFC 4648 descreve os alfabetos Base64 e seguro para URL. A forma segura para URL substitui os caracteres mais e barra usados pelo Base64 comum e, nesta ferramenta, omite o preenchimento final. Maiúsculas e minúsculas ainda importam em qualquer alfabeto Base64; não coloque em minúsculas um valor Base64 como se fosse texto UUID hexadecimal. Codificação URL é uma terceira escolha: chaves viram %7B e %7D, enquanto letras, dígitos e hífens do UUID canônico não precisam de substituição percentual.
Ordem de bytes faz parte de um contrato de intercâmbio. Esta página codifica bytes na mesma ordem de rede do texto hexadecimal canônico. A documentação de Guid.ToByteArray da Microsoft mostra que sua saída de bytes sem parâmetros inverte os três primeiros grupos de campos em relação ao texto. Se o receptor usa essa representação, compare explicitamente a ordem de bytes documentada; concordar que os dois campos contêm um GUID não estabelece que suas strings Base64 serão iguais.
Aspas também são uma camada. O formato de texto Entre aspas acrescenta caracteres de aspas a cada valor; uma apresentação JSON então escapa essas aspas dentro da string, e CSV as escapa dentro de um campo. Aspas escapadas extras podem, portanto, ser serialização correta e ainda assim estar erradas para um receptor que queria um UUID sem envoltório. Minúsculas mais Texto simples é um ponto de partida direto para importações JSON e CSV. Valores SQL usa strings entre aspas simples; forneça a estrutura de consulta ao redor separadamente e prefira consultas parametrizadas da aplicação em vez de colar strings geradas em uma consulta ativa.
| Escolha | Representação | Contrato receptor |
|---|---|---|
| Minúsculas / Texto simples | 550e8400-e29b-41d4-a716-446655440000 | Um UUID impresso. |
| Base64 | VQ6EAOKbQdSnFkRmVUQAAA== | 16 bytes em ordem de rede codificados com preenchimento. |
| Base64 URL | VQ6EAOKbQdSnFkRmVUQAAA | Os mesmos bytes com a representação segura para URL e sem preenchimento. |
| Chaves / Codificação URL | %7B550e8400-e29b-41d4-a716-446655440000%7D | Texto codificado percentualmente, não um campo UUID binário. |
Uma estrutura válida significa que o texto se encaixa em uma forma UUID aceita e que seus campos de versão e variante podem ser lidos. Ela não prova que o identificador foi gerado pelo ClockTools, por Web Crypto, por um serviço específico ou no horário v7 decodificado.
Para UUID v7, o timestamp é evidência útil apenas dentro de uma investigação maior. Ele pode refletir o relógio do dispositivo usado por um gerador, um timestamp alterado deliberadamente ou um valor de teste copiado. Trate-o como pista de ordenação e então compare com logs de servidor, timestamps de banco de dados e registros de auditoria confiáveis.
O inspetor aceita hexadecimal compacto ou texto com hífens, e pode remover envoltórios comuns como chaves, parênteses, aspas ou um prefixo urn:uuid: antes de conferir. Ele não decodifica Base64, Base64 URL ou entrada com codificação URL para validação; decodifique essas representações no sistema receptor antes da inspeção estrutural.
A inspeção aceita um identificador por vez, não uma linha CSV exportada ou array JSON. Usar valor gerado cola o primeiro UUID original do lote atual, não sua exibição codificada, então você pode inspecionar um lote mesmo com Base64 selecionado. O inspetor reconhece versões RFC aceitas de 1 a 8, mas a geração oferece apenas v4 e v7. Um aviso de variante não aceita ainda pode exibir uma forma normalizada; isso não é uma validação RFC bem-sucedida nem permissão para reescrever os campos do protocolo de origem.
| Observação | Conclusão razoável | Não conclua |
|---|---|---|
| Forma canônica exibida | O texto fornecido pode ser normalizado para texto UUID padrão. | O valor existe no seu banco de dados. |
| Variante é RFC 9562 | Os bits de variante correspondem ao layout RFC. | O valor é globalmente único em todo sistema. |
| Versão é UUID v7 | O campo de versão é 7 e um timestamp pode ser decodificado. | O timestamp é horário de criação verificado. |
| UUID nulo ou máximo | O valor é um padrão sentinela reservado. | Foi gerado como ID aleatório comum. |
| Variante ou versão não aceita | A forma parece UUID, mas está fora da leitura RFC aceita por este inspetor. | A entrada é segura para reescrever sem conferir o protocolo de origem. |
Um erro de quantidade significa que a contagem não é um número inteiro de 1 a 1.000. A ferramenta não arredonda, limita nem reduz silenciosamente a solicitação. Um erro de fonte aleatória significa que Web Crypto não forneceu bytes aleatórios utilizáveis, então nenhum identificador foi gerado.
Um erro de codificação pode ocorrer quando um navegador não tem a API necessária para a codificação de saída escolhida. Mude para Texto simples para recuperar o lote subjacente ou tente outro navegador. Uma falha de geração é diferente: ela descarta o lote em vez de manter valores parciais. Falhas de área de transferência, compartilhamento e download não regeneram identificadores. Quando o acesso de exportação falhar, selecione manualmente a saída visível se ela estiver disponível; confira downloads antes de presumir que um arquivo iniciado foi salvo.
Não cole segredos de produção em um relatório de UUID. Um UUID pode ser público, privado ou sensível à segurança dependendo de como seu sistema o usa, mas a forma sozinha não faz dele uma senha. Para tokens de portador, redefinições de senha ou credenciais de API, use um gerador de segredos e controles de ciclo de vida próprios para isso.
| Mensagem ou surpresa | Causa provável | Próxima conferência |
|---|---|---|
| Erro de quantidade | A quantidade está em branco, fracionária, negativa, zero ou acima de 1.000. | Informe um número inteiro de 1 a 1.000. |
| Aleatoriedade segura indisponível | O acesso a Web Crypto do navegador falhou. | Use um contexto seguro em navegador moderno; não aceite saída aleatória fraca. |
| Erro de duplicatas aleatórias | A janela limitada de tentativas não conseguiu preencher um lote único. | Gere novamente e investigue a fonte aleatória se repetir. |
| Erro de relógio para v7 | O horário do dispositivo não cabe no campo de timestamp v7. | Confira o relógio do sistema antes de confiar na ordenação v7. |
Base64 colado no validador falha | O validador espera texto UUID, não bytes codificados. | Decodifique o valor primeiro ou inspecione o texto UUID original. |
A geração preenche 16 bytes com aleatoriedade de Web Crypto do navegador e então define os bits RFC de versão e variante. UUID v4 deixa 122 bits aleatórios após esses campos fixos. UUID v7 escreve um timestamp Unix em milissegundos do relógio do dispositivo nos primeiros 48 bits do lote, preenche aleatoriamente os bits variáveis restantes e define versão 7 mais a variante RFC. A ferramenta confere unicidade apenas dentro do lote gerado e formata os 16 bytes resultantes conforme os controles selecionados.
A geração aceita apenas UUID v4 e v7, com quantidades inteiras de 1 a 1.000. Não há alternativa de aleatoriedade fraca, registro global de unicidade, consulta a banco de dados, contador v7 monotônico ou verificação de precisão do relógio. Saídas Base64 e Base64 URL são codificações dos 16 bytes, não entrada aceita pelo validador. Uma forma UUID válida não prova origem, propriedade, segredo, autorização ou existência de registro.
Para um relatório reproduzível, inclua modo, versão, quantidade, formato de texto, codificação, apresentação, navegador, erro visível exato e um valor de exemplo seguro. Para problemas de validação, forneça a string exata colada e a variante ou versão esperada. Não inclua credenciais de produção, tokens de portador, identificadores privados de clientes ou linhas de banco de dados quando um UUID público de teste demonstra o problema.