Ajuda técnica
Unix Timestamp para data: segundos, milissegundos e UTC explicados
Converta um Unix timestamp em data. Veja segundos versus milissegundos, UTC versus horário local, ISO 8601 e como voltar de uma data ao tempo epoch.
Um Unix timestamp representa o tempo em relação ao Unix epoch: 1970-01-01 00:00:00 UTC. Costuma ser guardado como segundos desde o epoch ou como milissegundos desde o epoch.
Para converter certo, primeiro você precisa saber a unidade. 1720000000 segundos são 2024-07-03 09:46:40 UTC. 1720000000000 milissegundos são o mesmo instante.
O timestamp identifica um instante. UTC, o horário local ou uma zona IANA só mudam como esse instante é exibido.
Este é um guia de conversão: timestamp para data, data para timestamp, UTC versus local, e ISO 8601. Se um valor vira de repente uma data de 1970, em geral é desencontro de segundos/milissegundos — veja Unix Timestamp em segundos vs milissegundos: por que a data vira 1970.
O que é um Unix Timestamp?
Unix timestamp, Unix time e epoch time costumam significar o tempo decorrido desde 1970-01-01 00:00:00 UTC. O número não é uma string de data formatada com rótulo de fuso horário. O mesmo instante pode aparecer com horas diferentes em UTC, Nova York, Tóquio ou Seul. Unix timestamps nem sempre são segundos — milissegundos são comuns na prática.
O que é o Unix Epoch?
O Unix epoch é 1970-01-01 00:00:00 UTC. O timestamp 0 é esse instante. Um timestamp positivo é depois do epoch. Alguns sistemas permitem um timestamp negativo para um momento antes do epoch, mas o suporte da linguagem e da faixa de datas varia.
Meu timestamp está em segundos ou em milissegundos?
1720000000 são segundos; 1720000000000 são milissegundos; são o mesmo instante. Uma pista prática: cerca de 10 dígitos costumam ser segundos; cerca de 13, milissegundos. A contagem de dígitos é só uma heurística. Datas passadas ou futuras, outras unidades ou um epoch personalizado podem parecer diferentes. Conversor de data e hora converte com segundos, milissegundos ou automático (≤10 dígitos como segundos, ≥13 como milissegundos) — escolha a unidade quando souber.
Por que a unidade errada gera a data errada?
JavaScript Date espera milissegundos. Passar 1720000000 como se fossem milissegundos resulta em 1970-01-20 21:46:40 UTC. Tratar milissegundos como segundos, ou o contrário, cai numa data bem diferente. Para o caminho de diagnóstico de 1970, veja Unix Timestamp em segundos vs milissegundos: por que a data vira 1970.
new Date(1720000000);
// 1970-01-20T21:46:40.000ZComo converter um Unix timestamp em segundos
Multiplique os segundos por 1000 para obter milissegundos. JavaScript Date é baseado em milissegundos, então use new Date(timestamp * 1000).
const timestamp = 1720000000;
const date = new Date(timestamp * 1000);
date.toISOString();
// 2024-07-03T09:46:40.000ZComo converter um timestamp em milissegundos
Passe os milissegundos para Date diretamente. Não multiplique de novo por 1000 um timestamp que já está em milissegundos.
const timestamp = 1720000000000;
const date = new Date(timestamp);
date.toISOString();
// 2024-07-03T09:46:40.000ZPor que o mesmo timestamp mostra um horário diferente?
Um Unix timestamp é um único instante. Exibi-lo em UTC, no horário local ou numa zona IANA escolhida muda o relógio. Para 1720000000000, UTC é 2024-07-03 09:46:40. America/New_York nessa data é 2024-07-03 05:46:40 (EDT). Asia/Seoul é 2024-07-03 18:46:40 (UTC+9). Esses valores de Nova York e Seul vêm de Intl, não de um slogan de deslocamento fixo.
Um Unix timestamp contém fuso horário?
Não. Ele não guarda America/New_York nem Asia/Seoul. O timestamp identifica um instante. O fuso é aplicado quando você formata esse instante como data e hora legíveis. O epoch é definido em relação a UTC; o número em si não é “um campo de fuso UTC”.
Unix Timestamp versus ISO 8601
1720000000 e 2024-07-03T09:46:40Z podem representar o mesmo instante. Unix é um valor numérico de tempo decorrido. ISO 8601 é uma string de data e hora legível e pode terminar em Z (UTC) ou num deslocamento numérico. Z significa UTC; às vezes se chama Zulu. Não são o mesmo formato.
Como obter o Unix timestamp atual?
Em JavaScript, Date.now() é milissegundos. Math.floor(Date.now() / 1000) é segundos. Não fixe um “agora” no artigo; ele se move.
Date.now();
Math.floor(Date.now() / 1000);Dá para converter uma data de volta para Unix timestamp?
Sim. A partir de uma string ISO UTC explícita, getTime() devolve milissegundos; divida por 1000 e arredonde para baixo para segundos.
const date = new Date("2024-07-03T09:46:40Z");
date.getTime();
// 1720000000000
Math.floor(date.getTime() / 1000);
// 1720000000Cuidado com formatos de data ambíguos
03/07/2024 pode ser 7 de março ou 3 de julho, conforme a região. Prefira data e hora no estilo ISO com fuso ou deslocamento. Conversor de data e hora recusa datas numéricas ambíguas como 01/02/2026 e pede um seletor de data ou um valor no estilo ISO.
E o horário de verão?
Um Unix timestamp não guarda uma marca de horário de verão. A exibição local aplica as regras da zona. America/New_York usa deslocamentos diferentes no inverno e no verão, então “Nova York é UTC-5” não é sempre verdade.
Unix timestamps incluem segundos intercalares?
O tempo POSIX/Unix típico não conta os segundos intercalares como segundos SI extras em uma escala contínua. As plataformas podem diferir. Na conversão do dia a dia você pode ignorar esse detalhe.
Erros comuns na conversão de Unix timestamp
Essas confusões geram a data errada ou o relógio errado:
Segundos tratados como milissegundos
Um valor moderno em segundos cai perto de 1970 no JavaScript Date.
Milissegundos tratados como segundos
A data pula para um futuro distante.
Tratar 10 ou 13 dígitos como lei
A contagem de dígitos é pista, não garantia.
Confundir UTC com o horário local
O instante é o mesmo; o relógio exibido pode diferir.
Assumir que há um fuso dentro do número
Os nomes IANA são aplicados na exibição, não guardados no timestamp.
Datas ambíguas, slogans de horário de verão ou ×1000 a mais
Use entrada no estilo ISO. Não multiplique de novo um timestamp em milissegundos.
Exemplos UTC verificados
Estes horários UTC foram calculados, não chutados:
| Entrada | Unidade | UTC |
|---|---|---|
| 0 | segundos | 1970-01-01 00:00:00 |
| 1720000000 | segundos | 2024-07-03 09:46:40 |
| 1720000000000 | milissegundos | 2024-07-03 09:46:40 |
| 1720000000 | milissegundos | 1970-01-20 21:46:40 |
Um guia simples para decidir a conversão
Se a fonte nomeia a unidade, use-a. Se não, a contagem de dígitos é uma pista — depois confira se a data parece plausível. Converta segundos em milissegundos quando a API precisar de ms. Escolha UTC, local ou uma zona IANA para exibir. ISO 8601 é útil para guardar e trocar.
- Você tem um Unix timestamp
- Unidade indicada? Use-a; senão, veja a magnitude
- Segundos? ×1000 se a API precisar de milissegundos
- Milissegundos? Use direto numa API baseada em ms
- Exiba como UTC, local ou uma zona IANA
- Precisa de uma string? ISO 8601 pode servir
O timestamp identifica um ponto no tempo. UTC, o horário local ou um fuso só decidem como esse instante é mostrado para uma pessoa.
Converta Unix timestamps no seu navegador
NEXNARA Conversor de data e hora converte segundos e milissegundos Unix, mostra UTC, horário local e ISO 8601, e converte entre fusos IANA.
O modo Unix aceita segundos, milissegundos, unidade automática, horário atual e data para timestamp. O modo de fuso busca nomes IANA, usa a zona do navegador e aplica deslocamentos Intl com horário de verão. O modo de formato tem saída legível por região, exibição 12/24 e um filtro de data ambígua. A diferença de datas é um modo à parte.
A conversão usa as APIs Date e Intl do navegador. Valores fora do que Date consegue representar são recusados. A unidade automática não adivinha valores de 11–12 dígitos; escolha segundos ou milissegundos.
A conversão de data e timestamp acontece no seu navegador. As entradas não são enviadas a um servidor da NEXNARA para conversão. Anúncios e outros recursos do site ainda usam a rede.
Cole um timestamp em Conversor de data e hora e compare UTC, horário local e ISO 8601 antes de escolher a unidade.
FAQ
Como converto um Unix timestamp em data?
Saiba a unidade. Em JavaScript, para segundos use new Date(n * 1000). Para milissegundos, new Date(n). Depois formate como UTC, local ou uma zona.
Unix timestamp é em segundos ou em milissegundos?
Pode ser os dois. Cerca de 10 dígitos costumam ser segundos e cerca de 13, milissegundos, mas isso é heurística, não regra.
Por que meu timestamp mostra 1970?
Em geral um valor em segundos foi lido como milissegundos. Veja Unix Timestamp em segundos vs milissegundos: por que a data vira 1970.
Unix timestamp é sempre UTC?
O epoch é definido em relação a UTC, e o número identifica um instante. O fuso de exibição é separado. Não é um “campo de fuso UTC” armazenado.
Um Unix timestamp contém fuso horário?
Não. Ele não carrega um identificador IANA. O fuso é aplicado quando você formata o instante.
Como converto uma data em Unix timestamp?
A partir de uma string ISO UTC, date.getTime() é milissegundos; Math.floor(date.getTime() / 1000) é segundos.