Conversor de Timestamp Unix

Atualizado: 4 outubro 2026

Converta um timestamp Unix (epoch time) numa data e hora legíveis, no horário local e em UTC, ou transforme qualquer data e hora num timestamp Unix em segundos ou milissegundos.

Converter Timestamps Unix

Fórmula do Timestamp Unix

Fórmula

\[ t = \left\lfloor \frac{ms}{1000} \right\rfloor \] \[ \text{Data} = 1970\text{-}01\text{-}01\ 00{:}00{:}00\ \text{UTC} + t\ \text{segundos} \] \[ t_{\text{local}} = t_{\text{UTC}} + t_{\text{offset}} \]

Onde:

\(t\) — o timestamp Unix, ou seja, o número de segundos completos decorridos desde a época Unix (1 de janeiro de 1970, 00:00:00 UTC)
\(ms\) — o mesmo valor expresso em milissegundos
\(t_{\text{offset}}\) — a diferença de fuso horário da sua localização em relação ao UTC, em segundos

A primeira linha converte um timestamp em milissegundos para segundos; a segunda define o que significa um timestamp — uma simples contagem de segundos somada à época Unix; a terceira desloca o horário UTC para o seu fuso horário local.

Timestamp Unix – Exemplo de Cálculo

Exemplo: converter o timestamp 1735689600 (segundos) numa data.

\[ 1735689600 \div 86400 = 20089\ \text{dias completos} \]

20089 dias inteiros após 1970-01-01 caem exatamente em 2025-01-01, com 0 segundos de resto, portanto a hora é meia-noite:

Resultado: 2025-01-01 00:00:00 UTC. No seu fuso horário local, o relógio marca meia-noite mais a sua diferença em relação ao UTC (por exemplo, 2025-01-01 01:00:00 para UTC+1). Em milissegundos, o mesmo instante é 1735689600000 ms.

Como Usar a Calculadora

Abra Direção da Conversão e escolha Timestamp → Data e Hora ou Data e Hora → Timestamp; os campos de entrada mudam automaticamente.
Para converter um timestamp, digite o número em Timestamp Unix e escolha Segundos ou Milissegundos na caixa Unidade. Valores negativos funcionam para datas anteriores a 1970.
Para a direção inversa, defina a Data e, opcionalmente, a Hora (deixe a hora vazia para meia-noite). Os valores são interpretados no seu fuso horário local.
Leia os resultados: Data e Hora Local com a sua diferença de UTC, Data e Hora UTC, o timestamp em segundos e milissegundos, e a linha ISO 8601 e Relativo, que também mostra o dia do ano e o dia da semana.

O Que É um Timestamp Unix?

Um timestamp Unix (também chamado de epoch time ou hora POSIX) é o número de segundos que passaram desde 1 de janeiro de 1970, 00:00:00 UTC — a chamada “época Unix”. Em vez de armazenar uma data como campos separados de ano, mês, dia e fuso horário, os computadores armazenam um único número inteiro que aumenta 1 a cada segundo. O timestamp 0 é a própria época; 1735689600 é exatamente 55 anos depois, e timestamps negativos contam para trás, até datas anteriores a 1970.

Essa representação é popular porque é compacta, fácil de comparar e totalmente livre de ambiguidade de fuso horário. Ordenar eventos, medir durações ou verificar “A aconteceu antes de B?” torna-se simples aritmética de inteiros. Você encontrará timestamps Unix em bancos de dados, arquivos de log, APIs (por exemplo, o Date.now() do JavaScript, que retorna milissegundos), tarefas cron e webhooks.

Ao interpretar um resultado, lembre-se da distinção entre UTC e horário local. Um timestamp sempre se refere a um único instante absoluto, mas a leitura do relógio depende da diferença de fuso de quem observa. Esta calculadora mostra ambos: a data e hora em UTC, que nunca muda, e a sua data e hora local, que o navegador deriva do fuso horário do seu dispositivo. A string ISO 8601 (2025-01-01T00:00:00.000Z) é a forma em UTC, terminando em Z de “Zulu time”.

A linha Relativo dá uma noção humana rápida de escala — “cerca de 6 meses atrás” ou “em 3 dias” — o que é útil ao ler logs de sistemas cujo relógio você não conhece, ou quando um timestamp vem de um cabeçalho como o campo HTTP Date.

Premissas, Limitações e Dicas

Segundos vs. milissegundos: muitos sistemas (JavaScript, Java) usam milissegundos, enquanto as ferramentas Unix e a maioria das APIs usam segundos. Se o seu número tem 13 dígitos, é quase certamente milissegundos; 10 dígitos geralmente significam segundos. Um erro comum é confundir um pelo outro, o que desloca a data em cerca de 31.700 anos.
Fuso horário local: na direção Data e Hora → Timestamp, a calculadora interpreta a sua entrada no fuso horário configurado no seu dispositivo. Se você precisa de um timestamp para um instante UTC específico, converta primeiro o seu horário local para UTC (por exemplo, subtraindo a sua diferença de fuso).
Timestamps negativos: datas anteriores a 1970 são representadas com números negativos; a calculadora as processa, mas alguns sistemas mais antigos não.
Segundos intercalares: o horário Unix padrão ignora os segundos intercalares — cada dia tem exatamente 86.400 segundos. Isso corresponde ao comportamento de praticamente todo o software, portanto nenhum ajuste é necessário no uso cotidiano.
Intervalo: o JavaScript (e, portanto, esta calculadora) suporta aproximadamente ±273.000 anos em torno de 1970, o que está muito além de qualquer data prática.
Verificação rápida: 1.000.000.000 de segundos ≈ 2001-09-09; 1.732.000.000 ≈ novembro de 2024. Memorizar um ou dois marcos de referência facilita detectar um dígito fora do lugar.

Ferramentas Relacionadas

Trabalhar com dados brutos frequentemente envolve outras codificações também. Se o seu timestamp está embutido num payload maior, experimente o Formatador de JSON para torná-lo legível, o Conversor de Hexadecimal ou o Conversor de Binário para inspecionar representações numéricas, e o Decodificador Base64 para desempacotar strings codificadas que frequentemente carregam valores de época em URLs e tokens de API.

Perguntas frequentes

Como converto um timestamp Unix numa data manualmente?

Divida o timestamp por 86.400 (o número de segundos de um dia) para obter o número de dias completos desde 1 de janeiro de 1970 e, em seguida, use o resto para encontrar a hora do dia. Por exemplo, 1735689600 ÷ 86400 = 20089 dias sem resto, o que cai exatamente em 2025-01-01 00:00:00 UTC. Fazer toda a matemática de conversão de dias para o calendário à mão é trabalhoso por causa dos anos bissextos, então um conversor é muito mais prático.

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

Conte os dígitos. Um número de 10 dígitos (como 1735689600) é quase sempre segundos e corresponde aproximadamente aos anos 2001–2033. Um número de 13 dígitos (como 1735689600000) é milissegundos — o mesmo instante, multiplicado por 1000. Confundir os dois é o erro mais comum de todos: desloca o resultado em cerca de 31.700 anos, um erro fácil de notar quando se conhece a regra.

Qual é o timestamp Unix atual agora?

O timestamp aumenta 1 a cada segundo, portanto não há uma resposta fixa — ele muda constantemente. Como pontos de referência úteis: 1.700.000.000 foi 2023-11-14, 1.750.000.000 é 2025-06-28 e 2.000.000.000 será 2033-05-18. Para obter o valor em tempo real, converta a data atual com esta calculadora ou execute Date.now() ÷ 1000 no console do seu navegador.

Um timestamp Unix pode ser negativo?

Sim. Timestamps negativos contam para trás a partir da época, então −86400 é 1969-12-31 00:00:00 UTC e −2.208.988.800 é 1 de janeiro de 1900. Esta calculadora aceita valores negativos, mas tome cuidado no código: alguns sistemas e bancos de dados mais antigos armazenam timestamps como inteiros sem sinal e não conseguem representar datas anteriores a 1970.

Por que o meu timestamp mostra uma hora diferente da do servidor ou de um arquivo de log?

Um timestamp sempre marca um único instante absoluto, mas a leitura do relógio depende da diferença de fuso horário de quem observa. O mesmo valor 1735689600 marca 00:00 em UTC, 01:00 em UTC+1 e 19:00 do dia anterior em UTC−5. Ao comparar valores entre sistemas, converta sempre primeiro para UTC; é por isso que a calculadora mostra a data e hora em UTC e a local lado a lado.

Qual é a diferença entre Unix time, epoch time e hora POSIX?

Nenhuma — os três nomes se referem à mesma coisa: a contagem de segundos desde 1 de janeiro de 1970 00:00:00 UTC. O horário Unix também ignora deliberadamente os segundos intercalares, tratando cada dia como exatamente 86.400 segundos. Isso significa que um timestamp não está perfeitamente sincronizado com o tempo atômico, mas corresponde ao modo como sistemas operacionais, bancos de dados e linguagens de programação realmente se comportam, portanto nenhuma correção é necessária na prática.

O que é o problema do ano 2038?

Sistemas mais antigos de 32 bits armazenam timestamps como um inteiro de 32 bits com sinal, que sofre overflow em 2038-01-19 às 03:14:08 UTC. Após esse instante, tais sistemas podem interpretar datas tão distantes quanto 1901. Plataformas modernas de 64 bits (incluindo o JavaScript, que esta calculadora usa) têm um intervalo de aproximadamente ±273.000 anos e não são afetadas, mas a questão ainda importa para dispositivos embarcados legados e esquemas de banco de dados antigos.