Conversor de timestamp Unix

O que é um timestamp Unix?

Um timestamp Unix, também chamado de tempo Unix, epoch ou hora POSIX, é o número de segundos que passaram desde 1º de janeiro de 1970, às 00:00:00 UTC. Esse instante é “o epoch”. Um segundo depois, o contador estava em 1; um dia depois, em 86.400.

O mesmo instante tem o mesmo timestamp em qualquer lugar da Terra. Os fusos horários só entram em cena quando o número vira uma data para alguém ler. É por isso que servidores, bancos de dados, logs e APIs adoram o timestamp: um único número inteiro, sem fuso, fácil de ordenar e de subtrair.

Segundos ou milissegundos?

A maioria dos sistemas conta em segundos, o que hoje dá um número de 10 dígitos. JavaScript, Java e muitas APIs contam em milissegundos: 13 dígitos. Alguns bancos de dados e ferramentas de rastreamento descem até microssegundos (16 dígitos) ou nanossegundos (19 dígitos).

O conversor acima olha o tamanho do número e escolhe a unidade para você. Se a data cair em 1970 ou num futuro muito distante, a unidade provavelmente estava errada: divida ou multiplique por 1.000.

O problema do ano 2038

Muitos sistemas antigos guardam o timestamp num inteiro de 32 bits com sinal. O maior valor possível é 2.147.483.647, que corresponde a 19 de janeiro de 2038, às 03:14:07 UTC. Um segundo depois, o contador estoura e vira −2.147.483.648, e esses sistemas passam a ler 13 de dezembro de 1901, às 20:45:52.

Os sistemas modernos de 64 bits estão tranquilos por bilhões de anos. O risco está em equipamentos embarcados, formatos de arquivo antigos, bancos de dados com colunas de 32 bits e código que converte o tempo para um inteiro de 32 bits. No Linux, as plataformas de 32 bits ganharam tempo em 64 bits com o kernel 5.6, em 2020, e a glibc 2.34, em 2021, mas os programas ainda precisam ser recompilados para aproveitar. Um bom teste: grave uma data em 2040 e leia de volta.

Tempo Unix e segundos intercalares

O tempo Unix faz de conta que todo dia tem exatamente 86.400 segundos. O UTC de verdade recebeu 27 segundos intercalares desde 1972, o último em 31 de dezembro de 2016. Durante um segundo intercalar, o tempo Unix em geral repete um segundo ou estica os segundos em volta, técnica chamada de smearing, usada por alguns grandes provedores de nuvem. Por isso um timestamp Unix não é uma contagem exata de segundos decorridos: é um número de dias vezes 86.400, mais os segundos do dia em curso.

Na prática, isso raramente importa, e vai importar cada vez menos. Em novembro de 2022, a Conferência Geral de Pesos e Medidas decidiu ampliar até 2035 a diferença permitida entre o UTC e a rotação da Terra, o que na prática acaba com os segundos intercalares. O Serviço Internacional de Rotação da Terra já anunciou que não haverá segundo intercalar no fim de dezembro de 2026.

Fusos horários e horário de verão

Um timestamp indica um instante, e não a hora de um relógio de parede. No timestamp 1.700.000.000, eram 22h13 em Lisboa, 19h13 em Brasília e 18h13 em Manaus: três horários locais, um número só. Para guardar datas, mantenha o timestamp (ou uma data ISO 8601 com “Z”) e converta para o horário local só na hora de mostrar. No banco de fusos que os sistemas usam, o horário de Brasília se chama America/Sao_Paulo.

O horário de verão mostra bem o motivo. O Brasil não adota mais o horário de verão desde 2019, mas até lá ele terminava à meia-noite, quando os relógios voltavam para 23h00: a hora das 23h00 à meia-noite acontecia duas vezes, e um horário local sozinho ficava ambíguo. Os timestamps, enquanto isso, seguiam subindo segundo a segundo, sem pulo. Na entrada do horário de verão, a hora local da meia-noite à 1h00 era pulada, mas nenhum timestamp ficava faltando. Datas antigas do Brasil ainda dependem dessas regras, e é o banco de fusos que as aplica.

Timestamp ou ISO 8601?

O ISO 8601 é o irmão legível do timestamp: 2023-11-14T22:13:20Z é o mesmo instante que 1.700.000.000. O timestamp é compacto e fácil de comparar; a data ISO é fácil de ler num log ou num arquivo JSON. Os dois não deixam dúvida, desde que a data ISO traga “Z” ou um deslocamento como −03:00.

Como obter um timestamp Unix no código

// Horário Unix atual em segundos (Date.now() está em milissegundos)
Math.floor(Date.now() / 1000)

// Timestamp para data
new Date(1700000000 * 1000).toISOString()   // "2023-11-14T22:13:20.000Z"

// Data para timestamp
Date.UTC(2026, 0, 1) / 1000                  // 1767225600

import time
from datetime import datetime, timezone

int(time.time())                                       # horário Unix atual
datetime.fromtimestamp(1700000000, tz=timezone.utc)    # 2023-11-14 22:13:20+00:00
int(datetime(2026, 1, 1, tzinfo=timezone.utc).timestamp())   # 1767225600

time();                                   // horário Unix atual
gmdate('Y-m-d H:i:s', 1700000000);        // "2023-11-14 22:13:20"
strtotime('2026-01-01 00:00:00 UTC');     // 1767225600

-- MySQL (FROM_UNIXTIME usa o fuso da sessão)
SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1700000000);

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM now())::bigint;
SELECT to_timestamp(1700000000);

-- SQLite
SELECT strftime('%s', 'now');
SELECT datetime(1700000000, 'unixepoch');

date +%s                              # horário Unix atual
date -u -d @1700000000                # Linux (date do GNU)
date -u -r 1700000000                 # macOS e BSD
date -u -d '2026-01-01 00:00' +%s     # 1767225600 (date do GNU)

Armadilhas comuns

• Horário local sem querer. Montar uma data a partir de “2026-01-01 00:00” sem fuso usa o horário local do computador. Acrescente “Z” ou “UTC”, ou use a opção UTC acima, quando você quer dizer UTC. No Brasil, a diferença é de 3 horas no horário de Brasília.
• Segundos lidos como milissegundos. Um número de 10 dígitos lido em milissegundos cai em janeiro de 1970. Um número de 13 dígitos lido em segundos cai daqui a dezenas de milhares de anos.
• Timestamps negativos. Datas antes de 1970 são números negativos: −86.400 é 31 de dezembro de 1969. A maioria das ferramentas modernas lida bem com eles, algumas antigas não.

Para ver que horas um timestamp marca em outra cidade, use o conversor de fuso horário. Para contar os dias entre duas datas, use a calculadora de datas, e para durações em horas e minutos, a calculadora de horas.