Gerador de GUID e UUID

O que é um GUID

São 128 bits, escritos como 32 dígitos hexadecimais em cinco grupos separados por hífen. A ideia central é não precisar de coordenação: duas máquinas que nunca se falaram podem gerar identificadores ao mesmo tempo com a garantia prática de que não vão colidir. É o que permite gerar a chave de um registro no cliente, antes de ele chegar ao banco.

Nem todos os 128 bits são aleatórios. Quatro guardam a versão e dois guardam a variante — por isso todo v4 tem um 4 no começo do terceiro grupo, e o quarto grupo sempre começa com 8, 9, a ou b. Sobram 122 bits de entropia no v4, e é sobre esse número que a conta de colisão é feita.

v4 ou v7: qual usar

A resposta curta: v7 para chave de banco de dados, v4 para o resto. A diferença é o que ocupa os primeiros 48 bits. No v4 eles são sorteados; no v7 são um carimbo de tempo em milissegundos, o que faz identificadores gerados em sequência aparecerem em sequência quando ordenados.

Isso importa porque um índice ordena. Com v4, cada inserção cai num ponto aleatório do índice, o que provoca divisão de página e fragmentação — e o custo cresce com a tabela. Com v7, a inserção é sempre no fim, que é o mesmo comportamento de um inteiro sequencial.

O preço do v7 é revelar quando foi criado. Se o identificador é público e o horário de criação é informação sensível — um pedido, um cadastro, um documento —, o v4 é a escolha certa justamente por não contar nada.

ULID e NanoID estão na tabela para comparação, e não como opção da ferramenta: não são UUID, não cabem num uniqueidentifier do SQL Server nem num Guid do .NET, e misturá-los aqui só faria você escolher entre quatro formatos parecidos sem saber a diferença.

Os formatos, e o que cada um vale em C#

Padrão, com hífens e minúsculo (ToString("D") no C#)

opções: nenhuma marcada
3f2504e0-4f89-41d3-9a0c-0305e82c3301

Sem hífens (ToString("N")) — o formato que cabe numa URL curta

opções: sem hífens
3f2504e04f8941d39a0c0305e82c3301

Entre chaves e em maiúsculas (ToString("B")) — o formato do registro do Windows

opções: chaves + maiúsculas
{3F2504E0-4F89-41D3-9A0C-0305E82C3301}

Em lote, com aspas e vírgulas — para colar num array ou num INSERT

opções: aspas + vírgulas, quantidade 3
"3f2504e0-4f89-41d3-9a0c-0305e82c3301",
"7c9e6679-7425-40de-944b-e07fc1f90ae7",
"a1b2c3d4-e5f6-4789-8abc-def012345678"

UUID v7 gerado em lote — repare que os primeiros dígitos crescem

opções: versão 7, quantidade 3
0192f8a1-2b00-7000-8f3a-1c4d5e6f7a8b
0192f8a1-2b00-7001-9b2c-3d4e5f6a7b8c
0192f8a1-2b01-7000-a5d6-7e8f9a0b1c2d

Como gerar GUID em C#

// v4 aleatório — o Guid de sempre
var id = Guid.NewGuid();

// v7 ordenável por tempo — .NET 9 em diante
var idOrdenavel = Guid.CreateVersion7();

// os cinco formatos, que são exatamente as opções desta ferramenta
id.ToString("D");   // 3f2504e0-4f89-41d3-9a0c-0305e82c3301   (padrão)
id.ToString("N");   // 3f2504e04f8941d39a0c0305e82c3301       (sem hífens)
id.ToString("B");   // {3f2504e0-4f89-41d3-9a0c-0305e82c3301} (chaves)
id.ToString("P");   // (3f2504e0-4f89-41d3-9a0c-0305e82c3301) (parênteses)
id.ToString("X");   // {0x3f2504e0,0x4f89,0x41d3,{0x9a,...}}  (hexadecimal, legado do COM)

// ler de texto sem estourar exceção
if (Guid.TryParse(entrada, out var lido)) { /* ... */ }

Cuidado: GUID não é gerador de token

Este é o erro mais caro da lista, porque não dá erro nenhum: usar Guid.NewGuid() como token de sessão, como link de recuperação de senha ou como chave de API. Um v4 tem 122 bits aleatórios, o que parece bastante — mas o contrato do método promete unicidade, não imprevisibilidade. Ele não garante que a fonte seja criptograficamente segura, e a implementação pode mudar entre plataformas.

Para qualquer segredo que alguém possa tentar adivinhar, peça bytes ao gerador que existe para isso:

using System.Security.Cryptography;

// ERRADO para token de sessão, link de recuperação de senha ou chave de API
var token = Guid.NewGuid().ToString("N");

// CERTO: pede bytes ao gerador criptográfico e diz quantos
var token = RandomNumberGenerator.GetHexString(64);      // .NET 9+
var bytes = RandomNumberGenerator.GetBytes(32);          // qualquer versão
var seguro = Convert.ToBase64String(bytes);

A mesma regra vale aqui nesta página, aliás: os identificadores acima são gerados por crypto.getRandomValues, o gerador criptográfico do navegador, e nunca por Math.random(). Se o navegador não expuser esse gerador, a ferramenta recusa gerar em vez de entregar algo previsível.

A pegadinha da ordem dos bytes

Um Guid do .NET e um UUID de qualquer outra linguagem são a mesma coisa em texto. Em bytes, não são. O .NET serializa os três primeiros campos em little-endian, herança do COM, enquanto a RFC 9562 especifica big-endian — então o mesmo identificador tem duas representações binárias diferentes.

var id = Guid.Parse("00000000-0000-0000-0000-000000000001");

// O texto sugere que o último byte é o mais significativo... mas:
id.ToByteArray();
// [0,0,0,0, 0,0, 0,0, 0,0,0,0,0,0,0,1]
//  ^^^^^^^  ^^^  ^^^  os TRÊS primeiros campos saem em little-endian

// .NET 8 em diante dá para pedir a ordem da RFC (big-endian):
id.ToByteArray(bigEndian: true);

O sintoma clássico aparece na ordenação: o tipo uniqueidentifier do SQL Server compara os últimos seis bytes primeiro, numa ordem que não corresponde nem à leitura do texto nem ao CompareTo do .NET. A mesma lista sai numa ordem no ORDER BY e em outra no OrderBy em memória. Se a ordem importa, não ordene por GUID — ordene por data ou por um sequencial.

Perguntas frequentes

Os GUIDs gerados aqui são enviados para algum servidor?

Não. Os identificadores são gerados no seu navegador, pelo gerador criptográfico do próprio navegador, e nunca saem da sua máquina — não passam por servidor nenhum, nem pelo nosso. Dá para conferir abrindo o DevTools na aba Network e clicando em gerar: nenhuma requisição nova parte. Isso importa porque GUID costuma virar identificador de registro real, chave de integração ou nome de arquivo em produção.

GUID e UUID são a mesma coisa?

Na prática, sim. UUID é o nome do padrão, definido hoje pela RFC 9562, e GUID é o nome que a Microsoft deu à mesma estrutura de 128 bits. Um Guid do .NET e um UUID de qualquer outra linguagem são intercambiáveis em texto. A única diferença real aparece em bytes: o .NET serializa os três primeiros campos em little-endian, herança do COM, enquanto a RFC especifica big-endian — o que muda a ordenação e a comparação binária.

Qual a chance de dois GUIDs v4 serem iguais?

Desprezível para qualquer uso real. Um GUID v4 tem 122 bits aleatórios — não 128, porque 4 bits guardam a versão e 2 guardam a variante —, o que dá cerca de 5,3 sextilhões de sextilhões de valores possíveis. A referência usual: depois de gerar 103 trilhões de GUIDs, a chance de existir uma colisão entre eles é de 1 em 1 bilhão. O risco prático não está na matemática, e sim em gerador mal implementado que use um sorteio previsível em vez de um gerador criptográfico.

Posso usar GUID v4 como chave primária no SQL Server?

Pode, mas não como chave primária CLUSTERIZADA, que é o padrão quando você declara a chave primária sem dizer nada. O índice clusterizado define a ordem física das linhas, e um GUID v4 é aleatório: cada inserção cai num ponto qualquer do índice, provocando divisão de página e fragmentação, o que degrada escrita e leitura conforme a tabela cresce. As saídas são três: usar NEWSEQUENTIALID() como default da coluna, usar UUID v7, que já nasce ordenado por tempo, ou manter o GUID como chave primária não clusterizada e clusterizar por uma coluna sequencial.

Qual a diferença entre UUID v4 e UUID v7?

O v4 é inteiramente aleatório: 122 bits sorteados, sem nenhuma informação embutida. O v7 troca os primeiros 48 bits por um carimbo de tempo em milissegundos, e sorteia o resto — então dois v7 gerados em ordem aparecem em ordem quando comparados como texto ou como bytes. Isso faz do v7 a escolha melhor para chave de banco de dados, porque a inserção passa a ser sempre no fim do índice. O preço é que o v7 revela QUANDO foi criado, o que é indesejável quando o identificador é público e o horário de criação é informação sensível.

Guid.NewGuid() serve para gerar token de sessão ou link de recuperação de senha?

Não use para isso. Guid.NewGuid() produz um v4 e tem 122 bits aleatórios, mas o contrato do método não garante que a fonte seja criptograficamente segura — ele promete unicidade, não imprevisibilidade, e a implementação pode mudar entre plataformas. Para qualquer segredo que alguém possa tentar adivinhar, use RandomNumberGenerator, do namespace System.Security.Cryptography, que existe justamente para isso e deixa você escolher quantos bytes quer. Um token de 32 bytes aleatórios é mais forte que um GUID e não carrega a ambiguidade.

Por que meu GUID ordena diferente no C# e no SQL Server?

Porque os dois comparam bytes em ordens diferentes. O tipo uniqueidentifier do SQL Server ordena pelos últimos seis bytes primeiro, e só depois pelos demais — uma ordem que não corresponde nem à leitura do texto nem ao Guid.CompareTo do .NET. O resultado é que a mesma lista de GUIDs sai numa ordem no ORDER BY e em outra no OrderBy do LINQ em memória. Se a ordem importa, não ordene por GUID: ordene por uma coluna de data ou por um identificador sequencial.

Quantos bits de um GUID v4 são realmente aleatórios?

122 dos 128. Quatro bits são fixos para indicar a versão — é por isso que todo GUID v4 tem o dígito 4 no começo do terceiro grupo — e dois bits indicam a variante, o que faz o primeiro dígito do quarto grupo ser sempre 8, 9, a ou b. Esses seis bits são o que permite a qualquer sistema reconhecer a versão do identificador só de olhar, e é a razão de o total de valores possíveis ser 2 elevado a 122, e não a 128.

Os v7 gerados aqui saem em ordem. O Guid.CreateVersion7() do .NET também?

Não dentro do mesmo milissegundo, e isso surpreende quem espera ordem total. A RFC 9562 trata o contador de monotonicidade como OPCIONAL: exige apenas que o carimbo de tempo de 48 bits ordene, e deixa livre o que fazer com os identificadores gerados no mesmo milissegundo. O .NET sorteia esses bits. Medindo no .NET 10, 500 chamadas seguidas a Guid.CreateVersion7() caíram todas no MESMO milissegundo e produziram 247 pares fora de ordem crescente — praticamente metade. Esta ferramenta implementa o contador descrito na seção 6.2 da RFC, então um lote gerado aqui sai estritamente crescente. Na prática isso raramente importa: o que o banco de dados aproveita é a ordenação por milissegundo, que os dois entregam. Só importa se você depender da ordem para desempatar registros criados no mesmo instante — e nesse caso o certo é não depender do identificador, e sim de uma coluna própria.

Como gerar GUID em C#?

Use Guid.NewGuid() para o v4 aleatório, que é o caso comum, e Guid.CreateVersion7() para o v7 ordenável por tempo, disponível a partir do .NET 9. Para exibir, o ToString aceita os especificadores D, N, B, P e X — que correspondem exatamente às opções de formato desta ferramenta. Para ler um GUID vindo de texto sem risco de exceção, use Guid.TryParse em vez de Guid.Parse.

Outras ferramentas

Todas as ferramentas estão em ferramentas para desenvolvedor — rodam no navegador, sem cadastro e sem anúncio.