uuidv7 | rfc 9562 | ordenável por tempo

> uuidv7 generator <

// UUIDs ordenados por tempo (RFC 9562, 2024) — timestamp Unix de 48 bits em ms + 74 bits aleatórios, gerados localmente

// DECODIFICAR / INSPECIONAR UM UUIDV7

Cole qualquer UUID abaixo para extrair seu timestamp incorporado, versão e variante. Funciona com v7 e informa se a entrada é uma versão diferente de UUID.

Timestamp (ms): // os campos decodificados aparecem aqui
ISO 8601 UTC: // os campos decodificados aparecem aqui
Idade: // os campos decodificados aparecem aqui
Versão: // os campos decodificados aparecem aqui
Variante: // os campos decodificados aparecem aqui
rand_a (12 bits): // os campos decodificados aparecem aqui
rand_b (62 bits): // os campos decodificados aparecem aqui
[RFC 9562]

UUIDv7 em conformidade com a especificação

Implementa o formato UUID ordenado por tempo da RFC 9562 (maio de 2024): timestamp Unix de 48 bits em milissegundos, versão 7 de 4 bits, rand_a de 12 bits, variante de 2 bits, rand_b de 62 bits. Verificado em relação aos vetores de teste da especificação.

[SORTABLE]

Ordem de classificação cronológica

Ordene numérica ou lexicograficamente e você obtém a ordem de inserção — perfeito para chaves primárias B-tree, índices de séries temporais e correlação de logs. Sem mais divisões de página aleatórias do v4 ou índices fragmentados.

[MONOTONIC]

Monotonicidade no mesmo milissegundo

Quando vários UUIDs caem em um milissegundo, a parte aleatória é incrementada rigorosamente para que a saída permaneça ordenada dentro desse ms. Desative para o Método 1 simples da RFC 9562 (preenchimento aleatório) se preferir.

[DECODER]

Inspecione qualquer UUIDv7

Cole um UUID v7 e o decodificador extrai o timestamp incorporado (ms + ISO 8601), os bits de versão, os bits de variante e os campos rand_a / rand_b. Útil para depuração, arqueologia de logs e trilhas de auditoria.

// SOBRE O UUIDV7

Como o UUIDv7 funciona:

Um UUIDv7 é um identificador de 128 bits estruturado como unix_ts_ms (48) | ver (4) | rand_a (12) | var (2) | rand_b (62). Os primeiros 48 bits são o timestamp Unix atual em milissegundos, big-endian, o que torna o UUID monotonicamente crescente no tempo. Os 4 bits seguintes codificam a versão (binário 0111 = decimal 7), então o terceiro grupo delimitado por hifens sempre começa com o dígito 7. rand_a são 12 bits aleatórios usados para resolução sub-milissegundo ou como entropia adicional. O campo de variante de 2 bits é fixado em 10 (então o primeiro caractere do quarto grupo é sempre 8, 9, a ou b). Os 62 bits restantes (rand_b) vêm de crypto.getRandomValues() em cada geração. A entropia total por UUID é de 74 bits aleatórios, resistente a colisões para qualquer taxa de geração realista.

Exemplo:

018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55 (ts=2024-05-08T15:00:00.000Z)

Padrões e referências:

  • >RFC 9562 — Universally Unique IDentifiers (UUIDs), maio de 2024 (torna obsoleta a RFC 4122, define v6/v7/v8)
  • >RFC 4122 — a especificação UUID original de 2005 (ainda autoritativa para v1-v5)
  • >Web Crypto API (W3C) — crypto.getRandomValues() CSPRNG usado para os 74 bits aleatórios
  • >Comportamento de gen_random_uuid() no PostgreSQL (v4 por padrão, v7 nas extensões pgcrypto / forks)
  • >draft-peabody-dispatch-new-uuid-format — a proposta original v6/v7/v8 que se tornou a RFC 9562

Por que usar UUIDv7:

  • >Chaves primárias de banco de dados com localidade de inserção — as páginas permanecem compactas, os índices não fragmentam
  • >Substitui um par sequência + UUID: uma coluna, ordenável E globalmente única
  • >Substitui chaves primárias v4 em tabelas com muitas escritas para corrigir o problema de divisão de página por inserção aleatória
  • >IDs de correlação de logs que se ordenam por hora de criação sem precisar de uma coluna de timestamp separada
  • >Sistemas distribuídos onde vários escritores precisam de IDs ordenados sem um coordenador
  • >Event sourcing / logs append-only onde a ordem cronológica é o índice natural
  • >Chaves de S3 / armazenamento de objetos onde a ordenação por prefixo corresponde à ordem de inserção
  • >Substitui Snowflake / KSUID / ULID onde um formato padrão é preferível

Ferramentas relacionadas:

  • >Gerador UUID — gera v4 (aleatório) e v1 (timestamp) quando você não precisa da ordenação do v7
  • >Gerador GUID — o mesmo identificador sob a nomenclatura da Microsoft
  • >Conversor de Timestamp — converte os ms Unix incorporados de volta para hora local / ISO 8601
  • >Conversor de Epoch — inspeciona a parte do timestamp de 48 bits em qualquer fuso horário
  • >Gerador de Senhas — tokens criptograficamente aleatórios quando a ordenabilidade não é necessária

// SAÍDAS DE EXEMPLO

Único UUIDv7 gerado agora

config: count=1, format=standard, timestamp=current

output:

018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55

Lote em massa com monotonicidade no mesmo milissegundo

config: count=5, format=standard, monotonic=on

output:

018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55
018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a56
018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a57
018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a58
018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a59

Timestamp histórico personalizado — preenchimento de uma migração

config: count=1, timestamp=custom, value=1577836800000 (2020-01-01)

output:

016f5e66-e800-7c9a-b403-2f1d4a7c91ee

Formato compacto para URLs / nomes de arquivo

config: count=1, format=no-hyphens

output:

018f5c2e90c07a4fb6ee8dfe3c2b0a55

UUIDv7 decodificado — inspecione os campos incorporados

config: input = 018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55

output:

ts_ms = 1715180400000
ISO   = 2024-05-08T15:00:00.000Z
ver   = 7
var   = 10 (RFC 4122)
rand_a = 0xa4f
rand_b = 0x36ee8dfe3c2b0a55

// IMPLEMENTE VOCÊ MESMO

A maioria das linguagens tem um auxiliar da biblioteca padrão ou uma implementação em arquivo único para UUIDv7 desde que a RFC 9562 surgiu em 2024. Abaixo estão as receitas canônicas que você pode incluir na sua base de código — em JS de navegador, Node.js, Go, Python e PostgreSQL.

[JavaScript]

UUIDv7 em JS puro de navegador/Node — estrutura RFC 9562

function uuidv7() {
  const ts = BigInt(Date.now());
  const rand = new Uint8Array(10);
  crypto.getRandomValues(rand);
  const b = new Uint8Array(16);
  b[0] = Number((ts >> 40n) & 0xFFn);
  b[1] = Number((ts >> 32n) & 0xFFn);
  b[2] = Number((ts >> 24n) & 0xFFn);
  b[3] = Number((ts >> 16n) & 0xFFn);
  b[4] = Number((ts >> 8n)  & 0xFFn);
  b[5] = Number( ts          & 0xFFn);
  b[6] = (rand[0] & 0x0F) | 0x70;   // version = 7
  b[7] =  rand[1];
  b[8] = (rand[2] & 0x3F) | 0x80;   // variant = RFC 4122
  for (let i = 9; i < 16; i++) b[i] = rand[i - 6];
  const h = Array.from(b, x => x.toString(16).padStart(2,'0')).join('');
  return `${h.slice(0,8)}-${h.slice(8,12)}-${h.slice(12,16)}-${h.slice(16,20)}-${h.slice(20)}`;
}

// usage:
const id = uuidv7();
console.log(id);   // -> '018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55'

// generate a batch and verify chronological sort:
const batch = Array.from({ length: 5 }, uuidv7);
batch.sort();      // sorts by creation time without a separate timestamp
[Node.js]

Node.js v26.1.0+ — crypto.randomUUIDv7() integrado

import { randomUUIDv7 } from 'node:crypto';

// Added in Node.js v26.1.0 (2026-05-07).
// Returns an RFC 9562 version 7 UUID. The first 48 bits encode a
// millisecond Unix timestamp; the rest is CSPRNG output.
const id = randomUUIDv7();
// -> '018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55'

// The CSPRNG output is cached for performance: Node generates enough
// entropy upfront for the next ~128 UUIDs. Pass disableEntropyCache: true
// when you need each call to draw fresh randomness, e.g. directly after
// a fork() or in tight high-security loops.
const freshId = randomUUIDv7({ disableEntropyCache: true });

// IMPORTANT: per the Node docs, "the embedded timestamp relies on a
// non-monotonic clock and is not guaranteed to be strictly increasing."
// If two UUIDs land in the same millisecond OR the system clock steps
// backwards, the IDs may not sort in creation order. Use a userland
// monotonic-v7 library (e.g. uuidv7 on npm) when strict ordering matters.
[Go]

Go — google/uuid v1.6+ inclui UUIDv7 nativamente

package main

import (
    "fmt"
    "github.com/google/uuid"
)

func newID() uuid.UUID {
    id, err := uuid.NewV7()
    if err != nil {
        panic(err)
    }
    return id
}

func main() {
    id := newID()
    fmt.Println(id.String())  // 018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55
    fmt.Println(id.Time())    // embedded creation timestamp
}
[Python]

Python 3.13+ — uuid.uuid7() da biblioteca padrão

import uuid

# Python 3.13 added uuid7() and uuid8() to the standard library.
uid = uuid.uuid7()
print(uid)            # 018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55
print(uid.version)    # 7

# For older Python use the 'uuid7' or 'uuid-utils' PyPI packages, or:
# from uuid_extensions import uuid7
[PostgreSQL]

PostgreSQL 18+ — função nativa uuidv7()

-- PG 18 ships uuidv7() natively. Use it as a primary key default:
CREATE TABLE events (
    id   uuid PRIMARY KEY DEFAULT uuidv7(),
    body jsonb,
    ts   timestamptz NOT NULL DEFAULT now()
);

-- For older Postgres, install the pg_uuidv7 extension or generate client-side.
-- Migration tip: keep INDEX on (id) only — v7 already sorts chronologically,
-- so a separate (created_at) index is usually redundant.

// ARMADILHAS COMUNS

> UUIDv7 revela a hora de criação — não use para tokens opacos

Os primeiros 48 bits de cada v7 são um timestamp Unix em milissegundos. Qualquer pessoa que veja o UUID pode decodificar quando o registro foi criado, a taxa em que os IDs são emitidos e (com várias amostras) aproximar o relógio do servidor. Isso é aceitável para chaves primárias de banco de dados internas e IDs de logs, mas para URLs de redefinição de senha, links de compartilhamento, IDs de sessão ou códigos de convite use UUIDv4 ou uma string aleatória gerada por CSPRNG.

> Regressão do relógio quebra a monotonicidade

Se o relógio do sistema saltar para trás (passo NTP, migração de VM, segundo bissexto), UUIDs v7 gerados de forma ingênua podem produzir valores que se ordenam antes de IDs emitidos anteriormente. A RFC 9562 §6.2 recomenda o Método 2 (aleatório monotônico): rastrear o último UUID gerado e, quando o timestamp não avança, incrementar a parte aleatória em vez disso. O botão Monotônico desta ferramenta faz exatamente isso.

> v7 não é um substituto direto do v4 em contextos sensíveis à segurança

IDs de aparência aleatória (v4) são frequentemente usados por engano como bearer tokens: «se você conhece o UUID, pode ler a linha». v7 tem apenas 74 bits aleatórios e um prefixo de timestamp previsível, o que ainda é resistente a colisões, mas oferece muito menos imprevisibilidade do que os 122 bits aleatórios do v4. Se algo é tratado como uma capability, gere um token criptográfico separado em vez de reutilizar a chave primária v7.

> Comparação de strings só funciona na forma minúscula e com hifens

A ordenação cronológica do v7 depende da comparação lexicográfica da string canônica de 36 caracteres em minúsculas — ou da comparação byte a byte do valor subjacente de 16 bytes. Misturar maiúsculas e minúsculas, remover hifens no meio do caminho ou armazenar algumas linhas entre {...} e outras sem produzirá uma ordenação que não corresponde mais à hora de criação. Escolha uma forma canônica por coluna e imponha-a com uma restrição CHECK.

> O timestamp de 48 bits estoura no ano 10889

2^48 milissegundos são aproximadamente 8.925 anos após a época Unix — o campo do timestamp transborda em 02-08-10889 UTC. Se o seu código afirma que o timestamp incorporado está em um intervalo sensato, defina o limite superior como 281.474.976.710.655 ms (o máximo que um inteiro sem sinal de 48 bits pode conter) em vez de codificar um ano próximo no futuro que estará errado dentro de um século.

>> perguntas frequentes

P: O que é UUIDv7?

R: UUIDv7 é um identificador de 128 bits definido na RFC 9562 (maio de 2024) que combina um timestamp Unix de 48 bits em milissegundos com 74 bits de aleatoriedade e os bits padrão de versão + variante. O resultado é um ID globalmente único que também se ordena cronologicamente por hora de criação — o melhor dos dois mundos. Foi projetado especificamente para corrigir a dor dos índices de banco de dados causada por chaves primárias UUIDv4 aleatórias, onde cada inserção cai em uma página B-tree diferente e causa enorme amplificação de escrita.

P: Como o UUIDv7 difere do UUIDv4?

R: UUIDv4 é totalmente aleatório (122 bits aleatórios) e não tem estrutura além dos campos de versão + variante. Dois v4 gerados com um microssegundo de diferença se ordenam em posições muito diferentes, o que é ótimo para imprevisibilidade, mas terrível para índices B-tree. UUIDv7 coloca um timestamp Unix de 48 bits em milissegundos no início, então v7 gerados próximos no tempo também se ordenam próximos no armazenamento. Compromisso: v7 revela a hora de criação e tem apenas 74 bits aleatórios em vez de 122 — ainda resistente a colisões, mas inadequado como token secreto.

P: Devo migrar de UUIDv4 para UUIDv7?

R: Para chaves primárias de banco de dados internas em tabelas com muitas escritas — sim, quase sempre. A fragmentação de índice que o v4 causa pode superar o custo das próprias consultas, especialmente no PostgreSQL ou MySQL com índices clusterizados InnoDB. Para tokens expostos aos usuários, incorporados em URLs ou tratados como capabilities («se você conhece o UUID pode acessar o recurso»), mantenha v4 ou use um token aleatório separado — v7 revela a hora de criação. Um padrão comum são chaves primárias v7 para joins internos mais um slug aleatório separado para a URL pública.

P: UUIDv7 é o mesmo que ULID, KSUID ou Snowflake?

R: Conceitualmente semelhantes — todos os quatro são IDs ordenados por tempo — mas os layouts de bits e codificações diferem. ULID usa Crockford base32 e um layout de milissegundos diferente. KSUID codifica um timestamp de 32 bits + payload de 128 bits como 27 caracteres base62. Snowflake é um ID de 64 bits específico do Twitter com IDs de worker. UUIDv7 é o equivalente padrão da IETF, codificado na forma hexadecimal canônica 8-4-4-4-12, de modo que toda biblioteca UUID, tipo UUID de banco de dados e driver JDBC/ODBC já o entende. Se você está começando do zero em 2025+, prefira v7 — é o padrão.

P: Quantos UUIDv7 posso gerar por milissegundo antes de colisões?

R: Dentro de um único milissegundo, apenas os 74 bits aleatórios (12 em rand_a + 62 em rand_b) garantem a unicidade. Pelo limite de colisão de aniversário, você pode gerar cerca de 2^37 ≈ 137 bilhões de v7 no mesmo ms antes de uma chance de colisão de 50% — efetivamente ilimitado para qualquer sistema realista. Entre milissegundos, o próprio timestamp desambigua, então o risco de colisão global ao longo da vida de um sistema é desprezível. Com o botão Monotônico ativado, as colisões intra-milissegundo são zero por construção (a parte aleatória é incrementada).

P: Posso extrair o timestamp de um UUIDv7?

R: Sim — o timestamp são os primeiros 48 bits, que são os primeiros 12 caracteres hexadecimais com os hifens removidos. Concatene os três primeiros grupos de hifens (8 + 4 = 12 hex digits), interprete como inteiro hexadecimal e você terá o timestamp Unix em milissegundos. Use o decodificador acima para fazer isso interativamente, ou no código: parseInt(uuid.replace(/-/g,'').slice(0,12), 16). O resultado é o instante em milissegundos em que o UUID foi gerado, preciso conforme o relógio do sistema naquele momento.

P: Como o dígito de versão aparece em um UUIDv7?

R: O terceiro grupo delimitado por hifens sempre começa com o dígito 7. Por exemplo: 018f5c2e-90c0-7a4f-b6ee-8dfe3c2b0a55. O quarto grupo sempre começa com 8, 9, a ou b — esses são os quatro valores possíveis com os dois bits altos sendo 10 (a variante RFC 4122). Se o dígito de versão não for 7, o UUID é de outra versão (comumente 4 para aleatório ou 1 para v1 baseado em tempo) e não se ordena cronologicamente.

P: PostgreSQL / MySQL suportam UUIDv7 nativamente?

R: PostgreSQL 18 (lançado em setembro de 2025) inclui uuidv7() como função integrada. Versões anteriores precisam da extensão pg_uuidv7 ou da geração no lado do cliente. MySQL 8.x não tem v7 nativo; use o auxiliar UUID_TO_BIN(uuid, 1) (que troca os bytes do timestamp para a ordem de classificação) apenas para v1 — para v7 gere no lado do cliente. SQL Server, Oracle e SQLite esperam todos a geração de v7 no lado do cliente. A maioria dos ORMs (Hibernate, Entity Framework, Sequelize, Prisma, SQLAlchemy) agora suporta v7 nativamente ou via plugin.

P: A opção monotônica é compatível com a RFC 9562?

R: Sim. A RFC 9562 §6.2 descreve explicitamente três métodos para garantir a ordenação intra-milissegundo: (1) preenchimento aleatório, (2) aleatório monotônico — incrementar um contador quando o timestamp não avança, (3) precisão de timestamp sub-milissegundo. A caixa de seleção Monotônico nesta ferramenta implementa o método 2: quando dois UUIDs compartilham o mesmo timestamp de 48 bits, a parte aleatória do segundo é definida como previous_random + 1 em vez de ser sorteada de novo. Isso garante ordenação rigorosa para geração em lote, permanecendo totalmente em conformidade com a especificação.

P: Meus dados são enviados para algum lugar?

R: Não. Toda a geração, decodificação, ordenação, cópia e download de UUIDv7 acontecem inteiramente no seu navegador como JavaScript puro. A página nunca faz uma requisição de rede quando você clica em GERAR, DECODIFICAR, COPIAR ou BAIXAR — você pode verificar com a aba Rede das ferramentas de desenvolvedor do seu navegador. Não registramos timestamps, seeds personalizadas, UUIDs gerados ou saídas decodificadas. A página em si é HTML estático servido por uma CDN, então nenhuma entrada chega à nossa infraestrutura. Isso torna a ferramenta segura para IDs de banco de dados de produção, logs internos ou qualquer outro dado que você prefira não passar por um servidor de terceiros.

P: Posso usar UUIDv7 em Java / .NET / Rust?

R: Sim. Java tem com.fasterxml.uuid:java-uuid-generator 5.0+ e o JDK 21 o tem via auxiliares de biblioteca. .NET 9 inclui Guid.CreateVersion7() na BCL. Rust usa Uuid::now_v7() do crate uuid atrás do feature flag v7. A maioria dos outros ecossistemas (Elixir, Ruby, PHP, Swift, Kotlin) também tem pacotes bem mantidos — pesquise «uuidv7» ou «uuid v7» no registro de pacotes da linguagem. O formato wire é idêntico em todos eles, então um v7 gerado em Go pode ser interpretado e ter o timestamp extraído por JavaScript sem qualquer transformação.

P: O Node.js tem um gerador UUIDv7 integrado?

R: Sim — a partir do Node.js v26.1.0 (lançado em 07-05-2026) a biblioteca padrão expõe crypto.randomUUIDv7([options]). Importe-o como import { randomUUIDv7 } from 'node:crypto' e chame-o sem argumentos para obter uma string UUID v7 RFC 9562. A única opção suportada é disableEntropyCache (booleano, padrão false); por padrão o Node armazena em cache dados aleatórios suficientes com antecedência para gerar os próximos ~128 UUIDs, a mesma otimização usada por crypto.randomUUID(). Ressalva importante da documentação oficial: «o timestamp incorporado depende de um relógio não monotônico e não há garantia de que seja estritamente crescente». Em outras palavras, dois UUIDs gerados no mesmo milissegundo, ou quaisquer UUIDs criados ao longo de um passo NTP / desvio para trás do relógio da VM, podem não se ordenar por hora de criação. Se você precisa de monotonicidade rigorosa dentro de um milissegundo, use uma implementação userland que siga a RFC 9562 §6.2 Método 2 (o pacote npm uuidv7, ou esta ferramenta com o botão Monotônico ativado).

P: Como armazeno UUIDv7 de forma eficiente em um banco de dados?

R: Armazene-o como um tipo binário de 16 bytes em vez de uma string de 36 caracteres — você economiza 20 bytes por linha, reduz pela metade o tamanho do índice e ganha um caminho de comparação mais rápido. Use o tipo uuid do PostgreSQL, MySQL BINARY(16), SQL Server uniqueidentifier ou SQLite BLOB. Adicione uma restrição CHECK de que o nibble de versão seja igual a 7 se quiser imposição. Com v7, as linhas se agrupam naturalmente por hora de criação, então um índice de cobertura em (uuid_pk) geralmente é suficiente — você não precisa de um índice (created_at) separado para consultas cronológicas.

// OTHER LANGUAGES