Formatos de timestamp Unix explicados

Unix time em segundos — o formato universal

O formato mais comum: um inteiro de 32 ou 64 bits que conta os segundos inteiros desde 1 de janeiro de 1970 00:00:00 UTC. Atualmente um número de 10 dígitos em torno de 1,7 bilhão.

• Exemplo: 1700000000 = 2023-11-15 06:13:20 UTC
• Usado por: Python time.time(), PHP time(), Go time.Now().Unix(), Ruby Time.now.to_i, C time(NULL)
• Armazenado como: int de 32 bits (legado, ano máx. 2038), int de 64 bits (moderno, seguro por bilhões de anos)
• Banco de dados: MySQL UNIX_TIMESTAMP(), PostgreSQL EXTRACT(EPOCH FROM NOW())::BIGINT

Unix time em milissegundos — o formato do JavaScript

Milissegundos desde o epoch Unix: um inteiro de 13 dígitos com precisão de milissegundo. É o formato que o objeto Date do JavaScript usa internamente.

• Exemplo: 1700000000000 = 2023-11-15 06:13:20.000 UTC
• Usado por: JavaScript Date.now(), Java System.currentTimeMillis(), .NET DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
• Para converter em segundos: Math.floor(ms / 1000)
• Para converter de segundos: seconds * 1000

ISO 8601 — o padrão legível por humanos

ISO 8601 é um padrão internacional para representar datas e horas como strings. Diferente dos timestamps Unix, é autodescritivo: o formato codifica a data/hora e o deslocamento de fuso.

• 2023-11-15T06:13:20Z — UTC (o sufixo Z significa UTC)
• 2023-11-15T01:13:20-05:00 — com deslocamento UTC explícito (EST)
• 2023-11-15T06:13:20.000Z — com milissegundos
• JavaScript: date.toISOString() sempre retorna UTC com sufixo Z
• Python: datetime.isoformat(), Go: time.Format(time.RFC3339)

RFC 2822 — formato de data de e-mail e HTTP

RFC 2822 (também chamado de RFC 1123 para HTTP) é o formato de data usado em cabeçalhos de e-mail e respostas HTTP. O Date.toUTCString() do JavaScript retorna esse formato.

• Exemplo: Wed, 15 Nov 2023 06:13:20 GMT
• Usado em: cabeçalhos de resposta HTTP (Last-Modified, Date, Expires), cabeçalhos de e-mail (Date:)
• JavaScript: date.toUTCString()
• Menos comum em APIs modernas, mas ainda muito presente na infraestrutura web

Como detectar o formato do timestamp

Ao receber um valor de timestamp desconhecido, use estas regras para identificar o formato:

• 10 dígitos, começa com 1 → segundos Unix (ex.: 1700000000)
• 13 dígitos, começa com 1 → milissegundos Unix (ex.: 1700000000000)
• Negativo → segundos ou milissegundos Unix anteriores a 1970
• Contém T ou Z → ISO 8601 (ex.: 2023-11-15T06:13:20Z)
• Contém vírgula ou nome de dia → RFC 2822 (ex.: Wed, 15 Nov 2023 ...)
• 16 dígitos → microssegundos (divida por 1,000,000 para segundos)
• 19 dígitos → nanossegundos (divida por 1,000,000,000 para segundos)

Microssegundos e nanossegundos

Alguns sistemas de alta precisão usam unidades menores que o milissegundo. São raras em código de aplicação, mas aparecem em sistemas de baixo nível, internos de bancos de dados e ferramentas de observabilidade.

• Microssegundos (µs): inteiro de 16 dígitos — Rust SystemTime as_micros(), PostgreSQL clock_gettime()
• Nanossegundos (ns): inteiro de 19 dígitos — Go time.Now().UnixNano(), Rust SystemTime as_nanos()
• PostgreSQL EXTRACT(EPOCH) retorna um número de ponto flutuante com os microssegundos como parte fracionária
• Para converter nanossegundos em segundos: divida por 1,000,000,000 (1e9)

FAQ sobre formatos de timestamp Unix

Quantos dígitos tem um timestamp Unix?

Um timestamp Unix moderno em segundos tem 10 dígitos (em torno de 1,7 bilhão); em milissegundos, 13. Microssegundos têm 16 dígitos e nanossegundos 19.

Qual é a diferença entre Unix time e ISO 8601?

Unix time é um único número de segundos ou milissegundos desde 1970 UTC e não carrega fuso. ISO 8601 é uma string autodescritiva como 2023-11-15T06:13:20Z que codifica data, hora e deslocamento.

Como detecto se um timestamp está em segundos ou milissegundos?

Conte os dígitos: 10 são segundos, 13 são milissegundos. Se um valor converte para uma data perto de 1970 ou muito distante, a unidade foi lida errado.