Timestamp Unix: como funciona e onde a conversão costuma errar

Números como 1795226400 aparecem em logs, bancos de dados e respostas de API. Este guia mostra como lê-los, por que o mesmo número vale em Brasília e em Lisboa, e onde as conversões costumam quebrar.

Atualizado em

Segundos contados desde 1970

Um timestamp Unix é o número de segundos desde a época (epoch): 1º de janeiro de 1970, 00:00:00 UTC. O POSIX o define por uma fórmula de calendário em que todo dia tem exatamente 86.400 segundos. Por exemplo, 1795226400 é 21/11/2026 às 02:00:00 UTC, ou seja, 20/11/2026 às 23:00 no horário de Brasília. Momentos antes de 1970 são negativos: -86400 é 31/12/1969 às 00:00 UTC.

Por ser um único número inteiro, o timestamp é fácil de guardar, comparar e subtrair. A diferença entre dois timestamps é o tempo entre eles em segundos, sem se preocupar com meses de tamanhos diferentes ou anos bissextos.

Segundos ou milissegundos

Muitos sistemas guardam a época em unidades menores, e a quantidade de dígitos entrega qual é. Para qualquer data entre 9 de setembro de 2001 e 20 de novembro de 2286, um timestamp em segundos (s) tem exatamente 10 dígitos. Abaixo, o mesmo instante, 21/11/2026 às 02:00 UTC, em segundos, milissegundos (ms), microssegundos (µs) e nanossegundos (ns):

UnidadeDígitosExemplo
s101795226400
ms131795226400000
µs161795226400000000
ns191795226400000000000

O Date.now() do JavaScript e o System.currentTimeMillis() do Java devolvem milissegundos; o time() do PHP devolve segundos. O time.time() do Python devolve segundos com fração, como 1795226400.25, e o UnixNano() do Go, nanossegundos. Confundir as unidades é o erro mais comum. Milissegundos lidos como segundos caem no ano 58858; segundos lidos como milissegundos caem em 21 de janeiro de 1970. Uma data que aparece em janeiro de 1970 quase sempre significa unidade trocada.

O timestamp não tem fuso horário

Um timestamp aponta para o mesmo instante no planeta inteiro. O fuso só entra quando esse instante vira hora de relógio. O Brasil tem quatro fusos, definidos pelo Decreto 2.784/1913 com a redação da Lei 12.876/2013, e 1795226400 aparece assim em cada um:

FusoUTCHora local
Fernando de Noronha−221/11, 00:00
Brasília−320/11, 23:00
Manaus, Cuiabá−420/11, 22:00
Acre, oeste do AM−520/11, 21:00

Repare que o mesmo evento cai em dias diferentes. Um relatório "do dia 20" calculado em UTC perde tudo o que aconteceu no Brasil entre 21:00 e meia-noite.

A regra prática: guarde timestamps ou UTC e converta para o fuso do usuário só na hora de mostrar. Use nomes de fuso da IANA, como America/Sao_Paulo e America/Manaus, em vez de um deslocamento fixo como −3. O horário de verão acabou em 2019, com o Decreto 9.772, e não voltou até novembro de 2026, mas dados antigos ainda passam por ele. Em America/Sao_Paulo, o horário de 0:30 de 4/11/2018 nunca existiu, porque o relógio pulou da meia-noite para a 1h, e as 23:30 de 16/2/2019 aconteceram duas vezes. Com um −3 fixo, registros desses verões ficam uma hora errados.

Cuidado também com datas sem fuso. No JavaScript, new Date('2026-11-21') é lido como meia-noite UTC, ou seja, 21:00 do dia 20 em Brasília, enquanto new Date('2026-11-21T09:00') é lido no horário local do aparelho. Duas linhas quase iguais, duas referências diferentes.

Segundo bissexto

O UTC de vez em quando insere um segundo bissexto para acompanhar a rotação da Terra. Foram 27 desde 1972; o último foi às 23:59:60 UTC de 31/12/2016, e desde então o UTC está 37 segundos atrás do tempo atômico (TAI). O tempo Unix ignora esses segundos, porque todo dia conta 86.400. Por isso a diferença entre dois timestamps em lados opostos do fim de 2016 é um segundo menor que o tempo que realmente passou. Não há outro previsto: o Boletim C do IERS de julho de 2026 não anunciou nenhum para o fim de dezembro de 2026, e em 2022 a Conferência Geral de Pesos e Medidas (CGPM) decidiu ampliar, até 2035, a diferença permitida entre UT1 e UTC.

O problema de 2038

Sistemas antigos guardam o timestamp como inteiro de 32 bits com sinal, cujo maior valor é 2.147.483.647: 19/01/2038 às 03:14:07 UTC. Um segundo depois o valor vira −2.147.483.648, que é lido como 13/12/1901. Um valor de 32 bits sem sinal vai até 7/2/2106, e 64 bits são praticamente ilimitados.

O limite antigo continua por aí. A coluna TIMESTAMP do MySQL só vai até 2038-01-19 03:14:07 UTC, enquanto DATETIME vai até o ano 9999. E o problema não espera 2038: um financiamento de 30 anos contratado hoje termina em 2056, então o sistema que calcula as parcelas já passou do limite.

Convertendo nas linguagens mais comuns

JavaScript:

Math.floor(Date.now() / 1000) // agora

const d = new Date(1795226400 * 1000);
d.toISOString();
// '2026-11-21T02:00:00.000Z'
d.toLocaleString('pt-BR',
  { timeZone: 'America/Sao_Paulo' });
// '20/11/2026, 23:00:00'

Date.parse('2026-11-20T23:00:00-03:00')
  / 1000; // 1795226400

Python 3.9 ou mais novo:

from datetime import datetime
from zoneinfo import ZoneInfo

sp = ZoneInfo('America/Sao_Paulo')
datetime.fromtimestamp(1795226400, sp)
# 2026-11-20 23:00:00-03:00

dt = datetime(2026, 11, 20, 23, 0,
              tzinfo=sp)
int(dt.timestamp())  # 1795226400

PHP, SQL e terminal:

// PHP
$d = new DateTime('@1795226400');
$d->setTimezone(
  new DateTimeZone('America/Sao_Paulo'));
echo $d->format('c');
// 2026-11-20T23:00:00-03:00

-- PostgreSQL
SELECT to_timestamp(1795226400);
-- MySQL, usa o fuso da sessão
SELECT FROM_UNIXTIME(1795226400);

date +%s                 # agora
date -u -d @1795226400   # Linux
date -u -r 1795226400    # macOS

Convertendo no swift.id

  1. Abra o Conversor de timestamp Unix. No alto aparecem o Timestamp Unix atual (segundos) e o valor Em milissegundos, cada um com o botão Copiar.
  2. Cole o número em Timestamp Unix. Com a Unidade em Automática, valores abaixo de 1011 são lidos como segundos, abaixo de 1014 como milissegundos, abaixo de 1017 como microssegundos e o resto como nanossegundos. Se o palpite errar, escolha a unidade. Frações como a saída do Python e separadores de milhar são aceitos.
  3. Leia o resultado em horário local, UTC, ISO 8601, RFC 2822 ou em relação a agora, e copie a linha de que precisa.
  4. Para o caminho inverso, preencha Data e Hora em Data para timestamp e escolha o Fuso horário; a lista traz Brasília, Amazonas, Acre e Fernando de Noronha. Se a hora escolhida caiu num pulo ou numa repetição do horário de verão, a ferramenta avisa e mostra qual momento usou.

Timestamps também se escondem dentro de UUIDs versão 7; o guia UUID v4 ou v7 mostra como ler um.

Perguntas frequentes

Por que a hora convertida está 3 horas adiantada?
O timestamp conta a partir do UTC. Um sistema que mostra o resultado em UTC fica 3 horas à frente do horário de Brasília e 5 à frente do Acre. Olhe a linha de horário local ou escolha o fuso certo ao converter uma data em timestamp.
Um timestamp pode ser negativo?
Pode. Momentos antes de 1º de janeiro de 1970 são negativos, por exemplo -86400 para 31/12/1969 às 00:00 UTC. Sistemas que guardam o timestamp como número sem sinal não conseguem representar datas antes de 1970.
O JavaScript tem o problema de 2038?
Não. Um Date guarda milissegundos num número de ponto flutuante de 64 bits e vai até o ano 275760. O problema aparece quando esse valor vai para uma coluna de banco ou outro programa que ainda usa 32 bits.
Uma API deve usar timestamp ou data ISO 8601?
Qualquer um, desde que sem ambiguidade. O timestamp precisa ter a unidade explícita, por exemplo num campo chamado created_at_ms. A data ISO 8601 precisa do deslocamento, como 2026-11-20T23:00:00-03:00, ou do sufixo Z para UTC.