Conversor de timestamp Unix
Converta entre timestamps Unix e datas legíveis
Referência de unidades de tempo
| Unidade | Segundos |
|---|---|
| 1 minuto | 60 |
| 1 hora | 3.600 |
| 1 dia | 86.400 |
| 1 semana | 604.800 |
| 30 dias | 2.592.000 |
| 365 dias | 31.536.000 |
| Evento | Timestamp |
|---|---|
| Época Unix | 0 |
| 1 bilhão (set 2001) | 1.000.000.000 |
| 1,5 bilhão (jul 2017) | 1.500.000.000 |
| 2 bilhões (mai 2033) | 2.000.000.000 |
| Y2038 (máx. 32 bits) | 2.147.483.647 |
| 3 bilhões (jan 2065) | 3.000.000.000 |
Obter o timestamp Unix atual em código
JavaScript / TypeScript
Math.floor(Date.now() / 1000) // seconds Date.now() // milliseconds
Python
import time int(time.time()) # seconds
PHP
time() // seconds microtime(true) // with microseconds
Go
time.Now().Unix() // seconds time.Now().UnixMilli() // milliseconds
Ruby
Time.now.to_i # seconds Time.now.to_f # with fractional
Java / Kotlin
System.currentTimeMillis() / 1000 // seconds Instant.now().getEpochSecond() // Java 8+
C# / .NET
DateTimeOffset.UtcNow.ToUnixTimeSeconds() DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
Rust
SystemTime::now() .duration_since(UNIX_EPOCH)?.as_secs()
Swift
Int(Date().timeIntervalSince1970) // seconds
Bash / Shell
date +%s # GNU/Linux date -j +%s # macOS
SQL (PostgreSQL)
SELECT EXTRACT(EPOCH FROM NOW()) SELECT NOW()::timestamp
SQL (MySQL)
SELECT UNIX_TIMESTAMP() SELECT FROM_UNIXTIME(1713024000)
O que é o tempo Unix?
O tempo Unix (também chamado de tempo Epoch, tempo POSIX ou timestamp Unix) é um sistema para rastrear o tempo como um total acumulado de segundos desde a época Unix — 1 de janeiro de 1970, 00:00:00 UTC. Foi introduzido com o sistema operacional Unix nos laboratórios Bell no final dos anos 60 e desde então se tornou a representação de tempo mais utilizada na computação.
A principal vantagem dos timestamps Unix é sua universalidade: eles representam o mesmo momento absoluto no tempo independentemente do fuso horário ou configuração regional. Um timestamp de 1713024000 sempre significa 14 de abril de 2024, 00:00:00 UTC — seja lido em Nova York, Londres ou Tóquio. Isso os torna ideais para armazenar timestamps em bancos de dados, sincronizar sistemas distribuídos e transmitir valores de tempo através de redes.
O tempo Unix ignora deliberadamente os segundos intercalares: cada dia é tratado como exatamente 86.400 segundos. Isso simplifica o cálculo ao custo de uma deriva ocasional em relação ao UTC. Na prática, a diferença é insignificante — menos de 30 segundos foram acumulados desde 1972, quando os segundos intercalares foram introduzidos.
A limitação mais significativa do tempo Unix foi o problema do Ano 2038. As implementações iniciais armazenavam timestamps como inteiros com sinal de 32 bits, que só podem representar valores até 2.147.483.647 — correspondendo a 19 de janeiro de 2038, 03:14:07 UTC. Os sistemas modernos migraram em grande parte para inteiros de 64 bits, que estendem o alcance para aproximadamente 292 bilhões de anos em cada direção.
Perguntas frequentes
O que é um timestamp Unix?
Um timestamp Unix é o número de segundos decorridos desde 1 de janeiro de 1970, 00:00:00 UTC (a "época Unix"). Ele representa um ponto no tempo como um único inteiro, independente de fusos horários. Por exemplo, o timestamp 0 é meia-noite de 1 de janeiro de 1970 UTC, e 1000000000 é 9 de setembro de 2001 às 01:46:40 UTC.
Como saber se um timestamp está em segundos ou milissegundos?
Conte os dígitos. Um número de 10 dígitos é segundos (ex.: 1713024000). Um número de 13 dígitos é milissegundos (ex.: 1713024000000). O Date.now() do JavaScript retorna milissegundos, enquanto a maioria das linguagens do servidor (Python, PHP, Go, Ruby) retorna segundos. Nosso conversor detecta o formato automaticamente.
O que é o problema Y2038?
Sistemas que usam inteiros com sinal de 32 bits para timestamps Unix só podem representar tempos até 19 de janeiro de 2038, 03:14:07 UTC (timestamp 2.147.483.647). Depois disso, o inteiro transborda. Sistemas modernos de 64 bits evitam isso completamente — um timestamp de 64 bits pode representar datas por cerca de 292 bilhões de anos.
O tempo Unix lida com segundos intercalares?
Não. O tempo Unix trata cada dia como exatamente 86.400 segundos, ignorando os segundos intercalares completamente. Quando um segundo intercalar é inserido no UTC, o tempo Unix efetivamente repete um segundo. A diferença acumulada é menor que 30 segundos desde 1972 — insignificante para a maioria das aplicações.
Por que o tempo Unix começa em 1 de janeiro de 1970?
A data foi escolhida durante o desenvolvimento do sistema operacional Unix nos laboratórios Bell no final dos anos 60. Era um número redondo (início de uma nova década) recente o suficiente para ser útil, e um inteiro de 32 bits podia cobrir tempo futuro suficiente para ser prático.
Timestamps Unix podem ser negativos?
Sim. Timestamps Unix negativos representam datas antes de 1 de janeiro de 1970. Por exemplo, -86400 representa 31 de dezembro de 1969. A maioria das linguagens de programação e nosso conversor suportam timestamps negativos corretamente.