Precisa de um identificador que não vai colidir com um que outra pessoa fez, em uma máquina que você nunca ouviu falar, sem pedir permissão a ninguém? Esse é o trabalho que um UUID faz. É um número de 128 bits, escrito como 36 caracteres no padrão familiar de 8-4-4-4-12, e todo o seu design é para que dois deles não sejam iguais, mesmo que nada coordene quem recebe o quê. Este gerador gratuito os cria no seu navegador: escolha uma versão em 'Versão', diga quantos você precisa em 'Quantidade' e pressione 'Gerar'. A página abre com um único v4, a versão que a maioria dos projetos quer, então um primeiro identificador está a um clique de distância.
Cada identificador é construído pelo seu navegador através da Web Crypto API. A versão 4 usa crypto.randomUUID() onde o navegador a fornece e crypto.getRandomValues() nos demais casos — uma fonte criptograficamente forte de aleatoriedade, em vez de uma função pseudoaleatória do JavaScript como o Math.random(). A versão 7 coloca um carimbo de data/hora (timestamp) de 48 bits em milissegundos na frente, depois um contador de 12 bits que aumenta dentro do mesmo milissegundo, depois 62 bits aleatórios, que é o método de ordenação descrito na RFC 9562; esse contador é a razão pela qual um lote de mil sai em ordem em vez de embaralhado. A versão 1 combina um carimbo de data/hora com um identificador de nó aleatório que tem o bit multicast ativado, então ela nunca carrega o endereço da sua placa de rede da maneira que as implementações originais da década de 1990 faziam. As versões 3 e 5 não são nada aleatórias: elas fazem o hash de um namespace junto com um nome, usando MD5 e SHA-1, respectivamente, e esse hash também acontece no seu dispositivo. Nada é enviado para um servidor, nada é registrado em logs e, depois que a página for carregada, ela continuará funcionando com a conexão desligada.
'Versão' é o campo que decide todo o resto. A versão 4 possui 122 bits aleatórios e nenhuma estrutura — o padrão, e a resposta certa quando um identificador só precisa ser único. A versão 7 mantém 62 bits aleatórios, mas começa com o momento em que foi criada, de modo que um conjunto deles é classificado na ordem em que foram criados; é isso que a torna a versão a ser escolhida quando o identificador se tornar uma chave de banco de dados. A versão 1 é o esquema original baseado em tempo, mantido aqui para os sistemas que ainda o pedem. As versões 3 e 5 são o par diferente: elas são determinísticas, ou seja, as mesmas entradas sempre produzem o mesmo identificador, e levam dois campos extras — 'Namespace', que é um dos espaços padrão DNS, URL, OID e X.500 ou um namespace 'Personalizado' próprio seu, e 'Nome', a string sendo identificada. Alimente a v5 com o namespace URL e https://example.com/a e você obterá o mesmo UUID hoje, amanhã e na máquina de outra pessoa. Por causa disso, 'Quantidade' desaparece quando a v3 ou a v5 é selecionada: mil cópias de um valor determinístico seriam apenas mil cópias de um valor determinístico. Para todas as outras versões, 'Quantidade' vai de 1 a 1000.
Quatro interruptores alteram o formato da saída sem alterar os 128 bits subjacentes. 'Maiúsculas' imprime os dígitos hexadecimais em caixa alta, 'Sem hifens' fornece a forma compacta de 32 caracteres que algumas colunas e nomes de arquivos preferem, e 'Chaves' envolve o valor em { } — a forma que o Windows e o mundo .NET chamam de GUID. Em 'Opções avançadas', urn:uuid: adiciona o prefixo que o torna um URN formal; isso desliga 'Chaves' e 'Sem hifens' enquanto está ativado, porque o padrão permite exatamente uma forma URN e é a forma canônica com hifens. 'Formato de cópia' decide como um lote é juntado quando você o pega: um por linha, separados por vírgulas, ou cada valor entre aspas com uma vírgula no final, que é colado direto num array em código. Sob o resultado fica uma linha que relata a aleatoriedade em bits — 122 para a v4, 62 para a v7 — e, no caso da v7, o carimbo de data/hora codificado no primeiro identificador do lote, para que o tempo dentro do valor fique visível em vez de implícito. 'Copiar tudo' e 'Salvar em arquivo' respeitam o 'Formato de cópia'. 'Histórico' guarda seus últimos 10 lotes no seu próprio navegador: clique em um para trazê-lo de volta, copie ou exclua uma única entrada, ou limpe tudo. 'Limpar' esvazia o resultado e deixa suas configurações como estão, e, após 50 identificadores, a lista se torna um único bloco rolável em vez de cinquenta linhas.
A coisa mais consequente nesta página é a diferença entre a v4 e a v7 como uma chave primária (primary key), e isso não é uma questão de gosto. Os índices de banco de dados são árvores (B-trees) mantidas em ordem de classificação, e o local onde uma nova chave cai nessa ordem decide quanto trabalho o insert custa. Uma chave v4 é aleatória, então os inserts consecutivos caem em cantos não relacionados do índice: páginas que estavam cheias são divididas (page split), as partes da árvore que o banco de dados está mantendo na memória raramente são as partes de que o próximo insert precisa, e o índice acaba maior e mais fragmentado do que as linhas para as quais ele aponta justificam. Uma chave v7 começa com o milissegundo atual, então inserts consecutivos caem próximos uns dos outros na borda direita da árvore, que é o padrão que um número inteiro de incremento automático produz e o padrão em torno do qual as estruturas de índice foram criadas. Esse é todo o trade-off: a v7 dá a você o comportamento de insert de uma chave sequencial, ao mesmo tempo que mantém a propriedade que o fez escolher UUIDs em primeiro lugar, que é o fato de que qualquer um pode cunhar um sem perguntar a um servidor. O que isso custa é que o tempo de criação agora pode ser lido dentro do identificador, e se isso importa é uma questão sobre os seus dados, não sobre o formato.
Nada nunca verifica um UUID para exclusividade; o seu tamanho é a garantia. Não há registro, nenhuma viagem de ida e volta ao servidor, nenhuma pesquisa — um gerador produz um número e o entrega, e a razão pela qual dois deles não colidem é simplesmente porque há 2^122 valores possíveis de v4, cerca de 5,3 undecilhões. O problema do aniversário (birthday problem) é a maneira honesta de dimensionar isso: você precisaria de cerca de 2,7 quintilhões de identificadores antes que houvesse uma chance de 50% de qualquer um dos dois corresponder, o que é um bilhão de novos UUIDs a cada segundo por 86 anos. Vale a pena ser preciso sobre o que isso promete ou não. É uma garantia estatística, não aritmética, e ela só é válida enquanto a aleatoriedade por baixo for real — um gerador semeado de forma ruim, ou uma máquina virtual clonada junto com seu pool de entropia, a quebra de uma maneira que o formato não consegue detectar. A versão 7 restringe a questão ainda mais: dentro de um único milissegundo, um gerador não consegue se repetir de jeito nenhum, porque o contador incrementa em vez de jogar dados, e em geradores independentes os 62 bits aleatórios fazem o trabalho.
Um UUID é um identificador, não uma senha. A versão 4 é imprevisível, e isso tenta as pessoas a tratá-la como um segredo — um link de redefinição de senha, um URL impossível de adivinhar, um token de sessão, uma chave de API. A imprevisibilidade é real, mas o sigilo é uma propriedade de como um valor é manuseado, e identificadores são manuseados sem cuidado por design: eles ficam em URLs, que acabam no histórico do navegador, em logs de servidor, em cabeçalhos de referrer e analytics, e são colados em mensagens de chat. As outras versões são candidatos ainda piores. Tanto a versão 1 quanto a versão 7 codificam o momento da criação, então qualquer pessoa que tenha uma delas sabe aproximadamente quando foi feita e pode restringir a vizinhança de tudo o que foi feito junto com ela. As versões 3 e 5 são determinísticas de propósito: um UUID v5 de um endereço de e-mail não é um segredo com hash, é um valor que qualquer um com o mesmo endereço pode computar em um segundo. Use um UUID para nomear uma coisa. Use um gerador de senhas, ou um token de uma biblioteca criada para segredos, quando o valor tiver que permanecer desconhecido.
Por que escolher esta ferramenta de gerar UUIDs?
- Geração apenas no navegador: identificadores são feitos no seu dispositivo e nunca são enviados para lugar algum
- Aleatoriedade da Web Crypto API: criptograficamente segura, não é Math.random()
- Cinco versões em um só lugar: v1, v3, v4, v5 e v7, sem mudar de ferramenta
- v7 genuinamente ordenada: um contador dentro do milissegundo, como a RFC 9562 descreve
- v3 e v5 determinísticas com os quatro namespaces padrão ou o seu próprio
- Até 1000 de cada vez, com uma lista rolável compacta passando de cinquenta
- Todas as formas comuns: com hifens, sem nada, maiúsculas, com chaves ou um URN urn:uuid:
- Cópia como linhas, vírgulas ou valores entre aspas que colam direto no código
- Ilimitado e gratuito: sem cadastro, sem limites de uso, nada nos nossos servidores
UUIDs aparecem sempre que algo tem que ser nomeado antes que qualquer coisa possa confirmar que o nome está livre. O código do aplicativo os cunha para linhas (rows) que está prestes a inserir, de forma que o objeto tem uma identidade antes mesmo de chegar ao banco de dados e um cliente pode referenciá-lo enquanto a gravação ainda está em andamento. Os sistemas distribuídos se apoiam neles com mais força: vários serviços gravando em uma tabela, um cliente móvel offline criando registros em um avião, uma fila que tem que reconhecer a mensagem que já processou — nenhum desses casos pode esperar sua vez por um contador compartilhado (shared counter). A versão 5 cobre uma necessidade diferente, que é um identificador estável derivado de algo que você já tem: o mesmo documento, o mesmo URL ou a mesma conta sempre mapeia para o mesmo UUID, então uma importação pode ser executada duas vezes sem duplicar nada. Em outros lugares, eles são simplesmente o formato que um sistema exige — um identificador de correlação encadeado em logs e traces, um nome de arquivo que não vai colidir quando os uploads de mil usuários caírem no mesmo bucket, uma chave de registro do Windows, um fixture de teste que precisa se parecer com dados reais.
Vale a pena conhecer alguns limites honestos. Um lote é uma versão: o valor em 'Versão' se aplica a tudo nele, então uma execução de v4s e uma execução de v7s são dois lotes. Isto é um gerador, não um inspetor — colar um UUID aqui para ler a sua versão ou o seu carimbo de data/hora não é algo que essa página faz. 'Salvar em arquivo' escreve um arquivo de texto simples em vez de CSV ou JSON. A versão 7 revela abertamente quando foi criada, até o milissegundo, o que é um trade-off real em vez de uma falha, e a versão 1 vaza o tempo da mesma maneira; se isso for um problema para os seus dados, a versão 4 é a versão que não conta nada a ninguém. Dois valores especiais do padrão não são versões e por isso não são opções em 'Versão', mas você pode copiá-los daqui: o UUID nil, 00000000-0000-0000-0000-000000000000, e o UUID max, ffffffff-ffff-ffff-ffff-ffffffffffff. Tudo nesta página segue a RFC 9562, a especificação que substituiu a RFC 4122 em 2024, de forma que a saída é aceita por qualquer biblioteca, banco de dados ou API que lida com UUIDs. Dentro desses limites, a garantia é forte: cada identificador é construído de acordo com o padrão, a partir de aleatoriedade criptograficamente segura, na sua própria máquina, e mais ninguém os vê.