Skip to content

Gerador de ULID Grátis — Gere e Decodifique ULIDs

Gere, decodifique e converta ULIDs online — grátis e 100% no navegador. Extraia o timestamp embutido de qualquer ULID, converta ULID para UUID e de volta, gere em lote, com modo monotônico. Nada é enviado a um servidor.

Sem rastreamento Roda no navegador Grátis
Cada ULID é gerado localmente com o RNG criptográfico do seu navegador (crypto.getRandomValues). Nada é enviado, registrado ou armazenado.

Cada ULID usa uma aleatoriedade nova de 80 bits.

O que é um ULID?

Um ULID — Universally Unique Lexicographically Sortable Identifier (Identificador Universalmente Único Ordenável Lexicograficamente) — é um identificador de 128 bits criado para corrigir uma fraqueza prática do UUIDv4 aleatório mantendo sua melhor propriedade: você pode gerar um em qualquer lugar, sem coordenador central, e confiar que é único. A diferença é que um ULID é ordenável por tempo. Ele é renderizado como 26 caracteres em Base32 de Crockford, dividido em duas partes: os primeiros 10 caracteres são um timestamp de 48 bits contando milissegundos desde a época Unix, e os últimos 16 caracteres são 80 bits de aleatoriedade criptograficamente segura. Coloque o tempo primeiro, codifique-o em um alfabeto que preserva a ordem, e o identificador se ordena cronologicamente como uma string simples.

Essa única escolha de design tem consequências enormes para bancos de dados. Uma chave primária UUIDv4 aleatória cai em um ponto imprevisível de um índice B-tree a cada inserção, o que fragmenta o índice, sobrecarrega o cache e degrada lentamente o desempenho de escrita à medida que uma tabela cresce. Um ULID, por ter prefixo de tempo, cai no fim ou perto do fim do índice toda vez — as inserções permanecem sequenciais, o índice permanece compacto e varreduras de intervalo sobre uma janela de tempo ficam baratas. Você obtém a geração sem coordenação de um UUID e a localidade de inserção de um inteiro auto-incremental, sem expor um contador sequencial adivinhável.

Os detalhes da codificação são deliberados. O Base32 de Crockford exclui as letras I, L, O e U, tanto para evitar confusão visual com os dígitos 1 e 0 quanto para tornar a string insensível a maiúsculas na entrada. O resultado são 26 caracteres sem hífens que podem ser colocados com segurança em uma URL, um nome de arquivo ou um cabeçalho de requisição sem escape — notavelmente mais curtos do que a forma de 36 caracteres com hífens de um UUID. O timestamp de 48 bits não se esgota por muito tempo: ele consegue representar datas até o ano 10889 antes de o contador de milissegundos transbordar.

ULIDs não são a ferramenta certa para tudo. O timestamp embutido revela quando um registro foi criado, o que é uma vantagem para depuração e ordenação, mas um pequeno vazamento de informação se você preferir não expor isso. E se sua stack está comprometida com o tipo UUID, você pode preferir o UUIDv7, que aplica a mesma ideia de prefixo de tempo dentro do formato UUID padrão. Mas quando você quer identificadores curtos, seguros para URL e ordenáveis que pode criar em qualquer nó e dos quais pode ler um timestamp de volta, um ULID é um excelente padrão — e, por ser apenas 128 bits, você sempre pode convertê-lo de e para um UUID com a aba Converter desta ferramenta.

// Browser / Node with the `ulid` package
import { ulid, decodeTime } from 'ulid';

const id = ulid();          // e.g. 01KVT0F720ZK9N4T2QX7VR8WMC
const ts = decodeTime(id);  // 1782210600000  ->  2026-06-23T10:30:00.000Z

// Monotonic factory: strictly increasing within the same millisecond
import { monotonicFactory } from 'ulid';
const next = monotonicFactory();
next(1782210600000); // 01KVT0F720ZK9N4T2QX7VR8WMC
next(1782210600000); // 01KVT0F720ZK9N4T2QX7VR8WMD
next(1782210600000); // 01KVT0F720ZK9N4T2QX7VR8WME

Recursos principais

Gere, Decodifique e Converta em Uma Página

Três abas cobrem todo o fluxo de trabalho do ULID: crie novos ULIDs, decodifique um existente para ler seu timestamp e converta sem perdas entre ULID e UUID. A maioria das ferramentas concorrentes faz só a primeira; aqui o ciclo completo de ida e volta vive em uma única página.

Decodificador de Timestamp

Cole qualquer ULID e leia o milissegundo exato em que foi criado — mostrado em UTC, no seu horário local e como milissegundos Unix brutos — além do segmento de 80 bits de aleatoriedade. Audite quando um identificador foi criado sem nenhuma consulta ao banco de dados.

Conversão ULID ↔ UUID Sem Perdas

Um ULID e um UUID têm ambos 128 bits, então a conversão é exata e reversível. A aba Converter detecta automaticamente qual formato você colou e produz o outro, permitindo fazer a ponte entre um ULID ordenável e uma coluna ou API tipada como UUID sem perder um único bit.

Modo Monotônico

Precisa de ordenação estrita mesmo para IDs criados no mesmo milissegundo? O modo monotônico incrementa a aleatoriedade para que cada ULID seja garantidamente maior que o último, mantendo um laço de inserção apertado perfeitamente ordenado.

Geração em Lote

Crie até 50 ULIDs de uma vez e copie o conjunto inteiro com Copiar Tudo. Ideal para semear fixtures de teste, inserções em massa ou popular uma tabela de consulta sem clicar cinquenta vezes.

Timestamp Personalizado

Embuta um momento específico em vez de agora — útil para dados de teste determinísticos ou para retrodatar registros durante uma migração mantendo a propriedade ordenável.

Aleatoriedade Criptograficamente Segura

Os 80 bits aleatórios vêm de crypto.getRandomValues, o CSPRNG do navegador — nunca Math.random — então cada ULID é imprevisível e colisões no mesmo milissegundo são minúsculas.

100% Privado, Só no Navegador

Cada ULID é gerado, decodificado e convertido inteiramente no seu dispositivo. Sem requisições de rede, sem registro de logs, sem armazenamento — verifique você mesmo em DevTools → Rede. Identificadores nunca chegam a terceiros.

Exemplos de ULID

Gerar um único ULID

Mode: Standard · Quantity: 1
01KVT0F720ZK9N4T2QX7VR8WMC

Um ULID tem 26 caracteres em Base32 de Crockford. Os primeiros 10 caracteres codificam um timestamp de 48 bits em milissegundos e os últimos 16 codificam 80 bits de aleatoriedade criptograficamente segura extraída de crypto.getRandomValues. Como o timestamp vem primeiro e o Base32 preserva a ordem dos bytes, ULIDs gerados depois sempre são ordenados após os anteriores como strings simples — sem necessidade de um índice separado. Clique em Copiar para pegar o valor; clique em Gerar de novo para um novo.

Decodificar um ULID para ler seu timestamp

01ARYZ6S41TSV4RRFFQ69G5FAV
Timestamp (UTC): 2016-07-30T22:36:16.385Z · Randomness: TSV4RRFFQ69G5FAV

Decodificar reverte os primeiros 10 caracteres de volta ao valor de 48 bits em milissegundos embutido no momento da criação — aqui 1469918176385 ms, que é 2016-07-30T22:36:16.385Z. Este é o exemplo canônico da especificação ULID. A aba Decodificar mostra o timestamp em UTC e no seu horário local, os milissegundos Unix brutos e o segmento de 80 bits de aleatoriedade, para que você possa auditar exatamente quando um identificador foi criado sem nenhuma consulta ao banco de dados.

Converter um ULID em um UUID

01KVT0F720ZK9N4T2QX7VR8WMC
019ef407-9c40-fcd3-5268-57e9f784728c

Um ULID e um UUID têm ambos exatamente 128 bits, então a conversão é sem perdas e totalmente reversível — os mesmos bits são simplesmente recodificados de Base32 de Crockford para hexadecimal com hífens. A aba Converter detecta automaticamente se você colou um ULID ou um UUID e converte para a outra forma. Isso permite armazenar ULIDs em uma coluna UUID ou entregar um ULID a um sistema que só fala UUID, e então converter de volta quando precisar novamente da string ordenável.

Gerar ULIDs monotônicos em lote

Mode: Monotonic · Quantity: 3 (same millisecond)
01KVT0F720ZK9N4T2QX7VR8WMC
01KVT0F720ZK9N4T2QX7VR8WMD
01KVT0F720ZK9N4T2QX7VR8WME

Quando muitos IDs são criados dentro do mesmo milissegundo, ULIDs comuns compartilham o prefixo de tempo de 10 caracteres, mas suas caudas aleatórias ficam sem ordem. O modo monotônico resolve isso: dentro de um milissegundo, ele incrementa a aleatoriedade anterior em um, então cada ULID é estritamente maior que o último e um lote permanece perfeitamente ordenado. Note que os três valores diferem apenas no caractere final (C, D, E) — ideal para inserções de alto volume onde a ordenação precisa se manter mesmo em taxas de sub-milissegundo.

Gerar um ULID para uma data específica

Custom time: 2026-06-23 10:30:00 UTC
01KVT0F720… (time component 01KVT0F720)

Defina um timestamp personalizado e o gerador embute esse momento exato em vez de agora, ainda preenchendo a aleatoriedade a partir de um RNG seguro. O componente de tempo de 10 caracteres para 2026-06-23T10:30:00.000Z é 01KVT0F720. Isso é útil para semear fixtures de teste com identificadores determinísticos e ordenados por tempo, ou para retrodatar registros em uma migração mantendo intacta a propriedade ordenável.

Como usar o gerador de ULID

  1. 1

    Escolha um modo de geração

    O modo Padrão dá a cada ULID uma aleatoriedade nova de 80 bits. O modo Monotônico garante que ULIDs criados dentro do mesmo milissegundo sejam estritamente crescentes — escolha-o para inserções de alto volume onde a ordenação precisa se manter mesmo em taxas de sub-milissegundo.

  2. 2

    Defina quantidade, caixa e (opcionalmente) um tempo personalizado

    Gere de 1 a 50 ULIDs de uma vez. A saída é em MAIÚSCULAS por padrão — a forma canônica do ULID — ou mude para minúsculas. Deixe o tempo vazio para carimbar agora, ou defina um timestamp personalizado para embutir um momento específico para fixtures ou registros retrodatados.

  3. 3

    Gere e copie

    Clique em Gerar ULID. Use Copiar em qualquer valor único, ou Copiar Tudo para pegar o lote inteiro como texto separado por quebras de linha pronto para colar em código, um arquivo de seed ou uma planilha.

  4. 4

    Decodifique um ULID para ler seu timestamp

    Na aba Decodificar, cole qualquer ULID para extrair o timestamp de criação de 48 bits em UTC e horário local, os milissegundos Unix brutos e os 80 bits de aleatoriedade — inteiramente no seu navegador, sem necessidade de consulta.

  5. 5

    Converta entre ULID e UUID

    Na aba ULID ↔ UUID, cole um ULID ou um UUID; a ferramenta detecta automaticamente a entrada e converte para o outro formato sem perdas. Armazene ULIDs em colunas UUID, ou entregue um ULID a um sistema que só aceita UUID e converta de volta quando precisar da string ordenável.

Common Errors

Tratar ULIDs do mesmo milissegundo como ordenados

ULIDs comuns criados dentro de um milissegundo compartilham o prefixo de tempo, mas têm caudas aleatórias sem ordem, então sua ordem relativa é indefinida. Se você depende de ordenação estrita nessa taxa, use o modo monotônico em vez disso.

✗ Incorreto 
Standard mode, 3 IDs in one ms  →  order within the ms is random
✓ Correto 
Monotonic mode, 3 IDs in one ms  →  …WMC < …WMD < …WME

Esperar que um ULID convertido seja um UUIDv4 válido

Converter um ULID para a forma UUID recodifica os mesmos 128 bits; não define os campos de versão e variante do UUID. O resultado é uma string UUID de 128 bits válida, mas não reportará como versão 4 ou 7 se uma biblioteca inspecionar esses bits.

✗ Incorreto 
uuid.version(ulidToUuid(id))  →  not 4 (bits are the ULID's)
✓ Correto 
Treat it as an opaque 128-bit value, or generate a real UUIDv7 instead

Usar i, l, o minúsculos em um ULID à mão

O Base32 de Crockford exclui I, L, O e U. Decodificadores mapeiam I e L para 1 e O para 0, mas digitar essas letras à mão em um ULID é propenso a erros. Copie ULIDs em vez de redigitá-los.

✗ Incorreto 
01ARYZ6S41TSV4RRFFQ69G5FAO  →  ambiguous O
✓ Correto 
01ARYZ6S41TSV4RRFFQ69G5FAV  →  canonical characters only

Para que servem os ULIDs

Chaves Primárias de Banco de Dados Que Permanecem Ordenadas
Use ULIDs como chaves primárias para obter a geração sem coordenação de um UUID com a localidade de inserção de um inteiro auto-incremental. Por terem prefixo de tempo, novas linhas são anexadas perto do fim de um índice B-tree em vez de se espalharem como o UUIDv4, mantendo as inserções rápidas e o índice compacto à medida que a tabela cresce.
Sistemas Distribuídos Sem uma Sequência Central
Gere identificadores em qualquer nó — serviço, edge worker ou cliente — sem um contador compartilhado e sem coordenação de colisão, e ainda ordene tudo pela hora de criação depois. ULIDs dão aos microsserviços uma chave única e ordenada sem uma ida e volta ao banco de dados para alocá-la.
Logs de Eventos e IDs de Mensagens
Carimbe eventos, linhas de log ou mensagens de fila com ULIDs monotônicos para que permaneçam em ordem cronológica estrita mesmo quando muitos são produzidos dentro do mesmo milissegundo. Varrer um intervalo de tempo se torna uma simples comparação de strings.
Identificadores Públicos Seguros para URL
Um ULID tem 26 caracteres sem hífens e um alfabeto seguro para URL, então cabe em um caminho, um nome de arquivo ou um cabeçalho sem escape e é mais curto do que um UUID de 36 caracteres. Decodifique o timestamp embutido depois para ver quando o recurso foi criado.
Ponte para um Sistema Que Só Aceita UUID
Trabalhando com uma coluna de banco de dados ou uma API que só aceita UUIDs? Gere ULIDs ordenáveis, converta-os para a forma UUID para armazenamento ou transporte, e converta de volta quando precisar da string ordenável e compacta — o valor de 128 bits é preservado com exatidão em ambas as direções.
Fixtures de Teste Determinísticas
Semeie testes com ULIDs em timestamps escolhidos usando a opção de tempo personalizado, para que as fixtures sejam reproduzíveis e já ordenadas por tempo. Decodifique-as em asserções para verificar a hora de criação que seu código registrou.

Como os ULIDs funcionam

Layout de 128 Bits: 48 Bits de Tempo + 80 Bits de Aleatoriedade
Um ULID tem exatamente 128 bits. Os 48 bits altos são um timestamp Unix em milissegundos; os 80 bits baixos são aleatórios. Codificados em Base32 de Crockford a 5 bits por caractere, isso dá 10 caracteres para o tempo e 16 para a aleatoriedade — 26 caracteres no total. O caractere inicial é sempre 7 ou menor porque 48 bits não preenchem o grupo superior de 5 bits.
Codificação Base32 de Crockford
ULIDs usam o alfabeto Base32 de Crockford (0–9 e A–Z excluindo I, L, O e U). Descartar essas quatro letras evita confusão com os dígitos 1 e 0 e permite que decodificadores tratem a string de forma insensível a maiúsculas, mapeando I e L para 1 e O para 0 na entrada. O alfabeto é ordenado, o que é o que faz a string codificada ordenar da mesma forma que os bits subjacentes.
Ordenabilidade Lexicográfica
Como o timestamp é o componente mais significativo e o alfabeto Base32 preserva a ordem, comparar dois ULIDs como strings produz o mesmo resultado que comparar seus valores de 128 bits, que produz o mesmo resultado que comparar suas horas de criação. É isso que permite que um simples ORDER BY ou sort de array produza ordem cronológica sem nenhum índice extra.
Monotonicidade Dentro de um Milissegundo
A opção monotônica da especificação ULID mantém a ordenação estável para IDs criados no mesmo milissegundo: a aleatoriedade do primeiro ID em um milissegundo é gerada normalmente, e cada ID posterior nesse milissegundo é o valor aleatório anterior mais um. Esta ferramenta implementa isso incrementando a aleatoriedade de 80 bits como um inteiro big-endian.
Aleatoriedade Segura via crypto.getRandomValues
Os 80 bits aleatórios são preenchidos a partir de crypto.getRandomValues, o CSPRNG do Web Crypto, não Math.random. Com 80 bits de entropia, gerar até milhões de ULIDs no mesmo milissegundo mantém a probabilidade de colisão desprezivelmente pequena.
ULID ↔ UUID É uma Recodificação Pura
Converter entre ULID e UUID não altera nenhum bit — recodifica os mesmos 128 bits de Base32 de Crockford para hexadecimal com hífens ou de volta. Como resultado, a ida e volta é exata: um ULID convertido em UUID e de volta é byte a byte idêntico ao original. Note que os bytes de um ULID não definem os campos de versão e variante do UUID, então o UUID resultante é um valor de 128 bits válido, mas não um UUIDv4 ou v7 marcado com versão.

Boas práticas de ULID

Use o Modo Monotônico para Inserções de Alto Volume
Se seu sistema pode criar mais de um identificador por milissegundo e você depende de ordenação, gere ULIDs monotônicos. ULIDs comuns não têm ordem dentro de um milissegundo; os monotônicos são estritamente crescentes, então um lote permanece ordenado não importa quão rápido você os crie.
Armazene ULIDs de Forma Compacta
Um ULID tem 128 bits — armazene-o como 16 bytes binários ou uma coluna tipada como UUID em vez de um campo de texto de 26 caracteres quando o espaço e o tamanho do índice importam. Converta para a string Base32 apenas nas bordas onde humanos ou URLs a veem. A aba Converter desta ferramenta dá a forma UUID para armazenamento.
Lembre-se de Que o Timestamp É Visível
Um ULID revela sua hora de criação a qualquer um que possa lê-lo. Isso é ótimo para depuração e ordenação, mas se expor a hora de criação é uma preocupação — digamos, em um identificador público — pese esse vazamento, ou use um UUIDv4 totalmente aleatório onde a ordenação não importa.
Sempre Gere com um CSPRNG
A garantia de unicidade depende de os 80 bits aleatórios serem imprevisíveis. Use uma fonte criptograficamente segura como crypto.getRandomValues, como esta ferramenta faz — nunca Math.random, cuja previsibilidade poderia permitir que identificadores colidissem ou fossem adivinhados.
Escolha ULID ou UUIDv7 Deliberadamente
Ambos dão IDs de 128 bits ordenados por tempo. Escolha ULID para a string segura para URL mais curta; escolha UUIDv7 quando precisar ficar no formato UUID padrão com bits de versão e variante. Padronize em um por sistema, e use a aba Converter quando precisar cruzar a fronteira.

ULID — perguntas frequentes

O que é um ULID?
Um ULID (Universally Unique Lexicographically Sortable Identifier — Identificador Universalmente Único Ordenável Lexicograficamente) é um identificador de 128 bits projetado como uma alternativa mais ordenável e mais compacta a um UUID. É escrito como 26 caracteres em Base32 de Crockford: os primeiros 10 caracteres contêm um timestamp de 48 bits em milissegundos desde a época Unix, e os 16 caracteres restantes contêm 80 bits de aleatoriedade. Como o timestamp é a parte mais significativa e o Base32 preserva a ordem, ULIDs criados depois sempre são ordenados após os anteriores quando comparados como strings simples — então uma coluna de ULIDs fica naturalmente ordenada por tempo. O alfabeto de Crockford exclui deliberadamente as letras I, L, O e U para evitar confusão com dígitos e para manter a string insensível a maiúsculas e segura para URL. ULIDs foram introduzidos para resolver um problema prático do UUIDv4 aleatório: identificadores aleatórios se espalham por um índice de banco de dados, prejudicando o desempenho de inserção, ao passo que um ULID com prefixo de tempo cai perto do fim do índice toda vez.
ULID vs UUID — qual devo usar?
Use um ULID quando você quer identificadores que sejam ao mesmo tempo únicos e naturalmente ordenáveis pela hora de criação; use um UUIDv4 clássico quando você precisa especificamente de um identificador opaco e totalmente aleatório, sem timestamp embutido. As diferenças principais: um ULID tem 26 caracteres em Base32 contra os 36 caracteres com hífens de um UUID, então ULIDs são mais curtos e seguros para URL sem escape. Um ULID codifica sua hora de criação, o que um UUIDv4 não faz — útil para ordenação e depuração, mas vale notar se você preferiria não expor quando um registro foi criado. Ambos têm 128 bits e ambos dispensam coordenação, então o risco de colisão é desprezível em qualquer um. Se sua stack padroniza em UUIDs mas você ainda quer ordenação por tempo, o UUIDv7 (do Gerador de UUID) oferece um design semelhante com prefixo de tempo no formato UUID — ou você pode gerar ULIDs aqui e convertê-los para UUID com a aba Converter.
ULIDs são ordenáveis?
Sim — essa é a característica que os define. Como o timestamp de 48 bits em milissegundos ocupa os primeiros 10 caracteres e o Base32 de Crockford preserva a ordem lexicográfica, ordenar ULIDs como strings comuns os ordena pela hora de criação. Isso vale em qualquer sistema que compara strings byte a byte: um ORDER BY de banco de dados, um conjunto ordenado, uma listagem de arquivos ou um simples sort de array. O ganho prático é o desempenho de banco de dados: chaves ordenadas por tempo são anexadas ao fim de um índice B-tree em vez de se espalharem aleatoriamente como o UUIDv4, o que mantém as inserções rápidas e o índice compacto. Dentro de um único milissegundo, a ordenação de ULIDs comuns é aleatória, então, se você precisa de ordenação estrita mesmo para IDs criados no mesmo milissegundo, use o modo monotônico, que incrementa a aleatoriedade para que cada valor seja garantidamente maior que o último.
Como decodifico o timestamp de um ULID?
Cole o ULID na aba Decodificar e a ferramenta extrai instantaneamente a hora de criação embutida, inteiramente no seu navegador. Ela lê os primeiros 10 caracteres, converte-os de Base32 de Crockford de volta para um inteiro de 48 bits de milissegundos desde a época Unix e mostra esse momento em UTC e no seu horário local junto com o valor bruto em milissegundos Unix. Por exemplo, o ULID canônico 01ARYZ6S41TSV4RRFFQ69G5FAV decodifica para 1469918176385 ms, ou 2016-07-30T22:36:16.385Z. Os 16 caracteres restantes são os 80 bits de aleatoriedade e não carregam significado para decodificar. Ler o timestamp dessa forma é prático para depuração, para auditar quando um registro foi criado ou para conferir se um identificador realmente é um ULID — sem nenhuma consulta ao banco de dados.
O que é um ULID monotônico?
Um ULID monotônico garante ordenação estrita mesmo para identificadores gerados dentro do mesmo milissegundo. ULIDs comuns criados em um milissegundo compartilham o mesmo prefixo de tempo de 10 caracteres, mas suas caudas aleatórias de 80 bits são independentes, então sua ordem relativa não é definida. A geração monotônica resolve isso: o primeiro ULID em um dado milissegundo recebe aleatoriedade nova, e cada ULID subsequente nesse mesmo milissegundo é produzido incrementando a aleatoriedade anterior em um. O resultado é uma sequência em que cada valor é estritamente maior que o anterior, então um lote inserido em um laço apertado permanece perfeitamente ordenado. Isso importa para sistemas de alto volume — logs de eventos, filas de mensagens, importações em massa — onde muitas linhas podem ser criadas mais rápido do que o relógio de milissegundos avança e você ainda precisa de uma chave estável e crescente.
Este gerador de ULID é seguro e privado?
Sim em ambos os aspectos. A aleatoriedade em cada ULID vem de crypto.getRandomValues, o gerador de números aleatórios criptograficamente seguro do navegador — nunca Math.random — então os 80 bits aleatórios são imprevisíveis e a chance de dois ULIDs colidirem no mesmo milissegundo é minúscula. Igualmente importante, tudo roda localmente: os ULIDs são gerados, decodificados e convertidos inteiramente no seu dispositivo. Nada é enviado, registrado ou armazenado, e você pode confirmar abrindo as DevTools e observando a aba Rede ficar silenciosa enquanto clica em Gerar. Essa propriedade de privacidade é toda a razão para criar identificadores no navegador em vez de em um servidor que poderia, em princípio, guardar uma cópia de cada valor que distribui.
Qual é a diferença entre ULID e UUIDv7?
Tanto ULID quanto UUIDv7 são identificadores de 128 bits ordenados por tempo que colocam um timestamp em milissegundos primeiro, então ambos ordenam pela hora de criação e ambos indexam de forma eficiente — a ideia central é a mesma. A diferença está no formato e na codificação. Um ULID é apresentado como 26 caracteres em Base32 de Crockford sem hífens, o que é mais curto e seguro para URL; o UUIDv7 é apresentado no layout UUID hexadecimal padrão de 36 caracteres com hífens e carrega bits de versão e variante em posições fixas, então é um UUID RFC 9562 totalmente válido que qualquer biblioteca de UUID aceita. Escolha UUIDv7 quando precisar permanecer no ecossistema UUID (uma coluna UUID de banco de dados, uma API tipada como UUID); escolha ULID quando quiser a string ordenável mais curta. Como ambos têm 128 bits, você pode gerar um ULID aqui e convertê-lo para a forma UUID com a aba Converter, ou gerar um UUIDv7 com o Gerador de UUID.

Ferramentas relacionadas

Ver todas as ferramentas →

Gerador e Verificador de Hash Bcrypt

Ferramentas de Segurança

Gere e verifique hashes bcrypt de senha online — custo ajustável, prefixos $2b$/$2a$/$2y$. 100% no seu navegador; sua senha nunca é enviada.

Decodificador JWT

Ferramentas de Segurança

Decodifique tokens JWT online com nosso decodificador JWT grátis. Inspecione cabeçalho, carga útil, assinatura, expiração e reivindicações. 100% navegador — seu token nunca sai do dispositivo. Sem cadastro, sem rastreio.

Codificador e Gerador JWT

Ferramentas de Segurança

Gerador e codificador JWT online grátis. Monte o cabeçalho e a carga útil, assine com HS256, RS256 ou ES256 instantaneamente. 100% no navegador — seu segredo e sua chave nunca saem do dispositivo.

Gerador de Segredo JWT — HS256/384/512

Ferramentas de Segurança

Gere um segredo JWT forte e correto pela RFC para HS256/384/512 — 100% no navegador, nunca enviado a um servidor. base64url, base64 ou hex; copie para o .env.

Gerador de Hash MD5 e Ferramenta de Checksum

Ferramentas de Segurança

Gere hashes MD5, SHA-256, SHA-1 e SHA-512 online gratuitamente. Faça hash de texto ou arquivos no navegador, verifique checksums e copie resultados. Sem cadastro necessário.

Gerador de Senhas Aleatórias — Forte e Seguro

Ferramentas de Segurança

Gere senhas aleatórias fortes instantaneamente — grátis, sem cadastro, 100% no navegador. Personalize comprimento e tipos de caracteres, gere em lote até 50. Medidor de força com análise de entropia.