Unix Timestamp em segundos vs milissegundos: por que a data vira 1970

Você converteu um timestamp e caiu em janeiro de 1970. Quase nunca é relógio quebrado. O número foi lido como milissegundos quando estava em segundos—ou o contrário.

O que é um Unix timestamp?

Um Unix timestamp mede o tempo desde o Unix epoch: 1970-01-01 00:00:00 UTC. Costuma usar segundos inteiros. O mesmo instante também pode ser guardado em milissegundos (segundos × 1.000). O número em si não indica a unidade.

Segundos vs milissegundos: a diferença ×1.000

Um segundo são 1.000 milissegundos. Compare 1720000000 com 1720000000000. Se o primeiro é segundos e o segundo milissegundos, marcam o mesmo instante. Leia o primeiro como milissegundos e a data pula rumo a 1970.

Estes resultados UTC foram calculados com os números acima—não chutados.

Valor	Unidade provável	Interpretação (UTC)
1720000000	Segundos	Data moderna lida como segundos: 2024-07-03 09:46:40 UTC
1720000000000	Milissegundos	O mesmo instante lido como milissegundos: 2024-07-03 09:46:40 UTC
1720000000 como milissegundos	Unidade errada	Data perto de 1970: 1970-01-20 21:46:40 UTC

Por que meu timestamp mostra 1970?

Se um valor em segundos é tratado como milissegundos, o número fica 1.000 vezes menor do que deveria. O JavaScript conta só um trecho curto depois do Unix epoch, e a data fica em 1970:

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

Essa data de 1970 é o epoch mais um par de semanas. Multiplique os segundos por 1.000 antes de passar ao Date.

• SEGUNDOS
• 1720000000
• × 1000
• ↓
• MILISSEGUNDOS
• 1720000000000

• Valor em segundos
• ↓
• Tratado por engano como milissegundos
• ↓
• Data perto de 1970

10 dígitos são segundos e 13 são milissegundos?

Em datas atuais, 10 dígitos costumam ser segundos e 13 milissegundos. É um indício rápido, não uma regra de validação. A quantidade de dígitos muda com o intervalo de tempo, e algumas APIs guardam microssegundos ou nanossegundos. Confirme a unidade na documentação ou com uma data que faça sentido.

Por que isso acontece tanto em JavaScript

No JavaScript, um Date numérico é milissegundos desde o epoch. Muitos backends, bancos e ferramentas Unix ainda guardam segundos. Passar um valor em segundos direto para Date é um bug comum:

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong fica perto de 1970 (1970-01-20 21:46:40 UTC). correct é o instante moderno (2024-07-03 09:46:40 UTC).

Outros sistemas usam unidades diferentes

Outras linguagens, APIs e bancos podem usar segundos ou milissegundos. Alguns guardam microssegundos ou nanossegundos. Não assuma que uma linguagem usa sempre uma unidade: veja a documentação. Se o número está em JSON, Formatar e comparar JSON deixa o campo legível; ainda assim não revela a unidade.

Como saber qual unidade meu timestamp usa?

Siga estas checagens nesta ordem. Só a quantidade de dígitos não basta.

1. Consulte a documentação da API ou do banco de dados.
2. Olhe o número aproximado de dígitos.
3. Compare o valor com um timestamp moderno plausível.
4. Teste o valor como segundos e como milissegundos.
5. Veja se a data resultante faz sentido.

Se uma interpretação cai em 1970 e a outra numa data que você reconhece, a causa é o descompasso de unidades.

Erros comuns com Unix timestamp

• Segundos interpretados como milissegundos. A data colapsa rumo a 1970, como no exemplo.
• Milissegundos interpretados como segundos. A data dispara para o futuro distante, ou a conversão falha.
• Multiplicar por 1.000 duas vezes. Um valor que já era milissegundos fica enorme e a data avança séculos.
• Dividir por 1.000 duas vezes. Um valor em segundos encolhe de novo, de volta para perto de 1970.
• Culpar o fuso horário. Um fuso pode mudar horas ou o dia no calendário. Não joga um timestamp moderno para 1970.
• Tratar uma data formatada como Unix timestamp. Um valor como 2024-07-03T09:46:40Z não é um número epoch. Analise como data, não como segundos.

O fuso horário causa o problema de 1970?

Em geral, não. Um fuso pode mudar o relógio exibido e, perto da meia-noite, a data do calendário. Não transforma um Unix timestamp moderno em 1970. Se o resultado é 1970, confira primeiro segundos versus milissegundos.

Converter e conferir um Unix timestamp

NEXNARA Conversor de data e hora pode converter um Unix timestamp no navegador.

Cole segundos ou milissegundos Unix, use o timestamp atual, veja UTC e hora local, converta fusos e formate uma data. A detecção automática costuma tratar 10 dígitos como segundos e 13 como milissegundos; você ainda pode escolher a unidade.

A conversão acontece no seu navegador. Esta ferramenta não envia datas nem timestamps a um servidor da NEXNARA. Anúncios e outros recursos do site ainda usam a rede; isso é separado da conversão.

Precisa conferir um Unix timestamp? Abra Conversor de data e hora e compare segundos com milissegundos.

FAQ

Por que meu Unix timestamp mostra 1970?

Muitas vezes são segundos lidos como milissegundos. O JavaScript trata um número bem menor, então a data fica logo depois de 1970-01-01 00:00:00 UTC. Multiplique os segundos por 1.000 e converta de novo.

Unix timestamps são segundos ou milissegundos?

Em geral usam segundos. Muitas APIs web e o Date do JavaScript usam milissegundos. Veja o que aquele sistema documenta. Alguns usam microssegundos ou nanossegundos.

Como converter segundos em milissegundos?

Multiplique por 1.000. 1720000000 segundos são 1720000000000 milissegundos. No outro sentido, divida por 1.000.

Por que o Date do JavaScript usa milissegundos?

O timestamp numérico de Date no JavaScript é definido como milissegundos desde o Unix epoch. Por isso new Date(unixSeconds) está errado quando unixSeconds está em segundos Unix.

Um timestamp de 10 dígitos é sempre segundos?

Não. Em datas atuais costuma ser segundos, e 13 dígitos costumam ser milissegundos. A contagem de dígitos é um indício, não uma regra. Confirme na documentação ou com uma data coerente.

Um Unix timestamp contém fuso horário?

Não. Um Unix timestamp é um instante contado a partir de 1970-01-01 00:00:00 UTC. Fusos afetam como esse instante é exibido, não o número em si.