0
1970-01-01T00:00:00Z
946684800
2000-01-01T00:00:00Z
2147483647
2038-01-19T03:14:07Z — max for 32-bit signed int
9223372036854775807
~292 billion years — no practical overflow
86400000
60 × 60 × 24 × 1000
31536000
365 × 24 × 60 × 60 (non-leap)
2024-01-15T12:30:00Z
YYYY-MM-DDTHH:MM:SSZ — widely recommended
2024-01-15T07:30:00-05:00
YYYY-MM-DDTHH:MM:SS±HH:MM
Mon, 15 Jan 2024 12:30:00 +0000
Used in email headers and HTTP headers
2024-01-15T12:30:00.000Z
Subset of ISO 8601 with milliseconds
Mon, 15 Jan 2024 12:30:00 GMT
Used in HTTP headers (Last-Modified, Date)
01/15/2024
Ambiguous — avoid in APIs
15/01/2024
Ambiguous — avoid in APIs
2024-01-15
SQL DATE type, BigQuery, Redshift
20240115123000
Lexicographically sortable
Date.now()
Returns milliseconds since epoch
Math.floor(Date.now() / 1000)
Returns whole seconds
new Date(ts * 1000).toISOString()
Multiply by 1000 if ts is in seconds
Math.floor(new Date('2024-01-15T12:30:00Z').getTime() / 1000)import time; time.time()
Returns float with sub-second precision
from datetime import datetime, timezone datetime.fromtimestamp(ts, tz=timezone.utc)
Always pass tz=timezone.utc to avoid local timezone
from datetime import datetime, timezone
datetime.fromisoformat('2024-01-15T12:30:00+00:00').timestamp()SELECT EXTRACT(EPOCH FROM NOW())::BIGINT;
Returns whole seconds
SELECT to_timestamp(1705319400);
SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1705319400);
time.Now().UnixNano()
Nanoseconds precision
time.Now().Unix()
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
time()
Returns seconds; microtime(true) for float
date +%s
GNU/BSD date; on macOS same command works
+00:00
Coordinated Universal Time — no DST
-05:00 / -04:00
EST in winter, EDT in summer (DST)
-06:00 / -05:00
-07:00 / -06:00
-08:00 / -07:00
+00:00 / +01:00
BST (British Summer Time) in summer
+01:00 / +02:00
Germany, France, Italy, Poland, etc.
+05:30
No DST — half-hour offset
+08:00
No DST — entire country one timezone
+09:00
No DST
+10:00 / +11:00
DST in southern hemisphere summer (Oct–Apr)
+12:00 / +13:00
| Unidade | Dígitos | Exemplo | Intervalo aprox. |
|---|---|---|---|
| Seconds (s) | 10 | 1705319400 | 1970 – 2286 |
| Milliseconds (ms) | 13 | 1705319400000 | 1970 – 2286 (×1000) |
| Microseconds (μs) | 16 | 1705319400000000 | Sub-second precision |
| Nanoseconds (ns) | 19 | 1705319400000000000 | Used by Go, Rust, Linux kernel |
Unix timestamps são sempre UTC. Eles não contêm informação de fuso horário. Na verdade, isso é uma vantagem — fornece um ponto de referência universal.
A confusão surge ao converter timestamps para datas legíveis por humanos:
const ts = 1700000000;
const date = new Date(ts * 1000);
date.toUTCString(); // "Tue, 14 Nov 2023 22:13:20 GMT"
date.toLocaleString(); // Depende do fuso horário local do usuário
date.toISOString(); // "2023-11-14T22:13:20.000Z"
Boa prática: Armazene e transmita timestamps em UTC. Converta para o horário local apenas na camada de apresentação, o mais próximo possível do usuário.
-- Timestamp atual
SELECT EXTRACT(EPOCH FROM NOW());
-- Timestamp para data
SELECT TO_TIMESTAMP(1700000000);
-- Data para timestamp
SELECT EXTRACT(EPOCH FROM '2023-11-14'::timestamp);
Se uma data aparece como janeiro de 1970, provavelmente você passou segundos onde milissegundos eram esperados (ou vice-versa). Sempre verifique qual precisão a API espera.
Ao armazenar timestamps como números de ponto flutuante, você pode perder precisão além dos milissegundos. Para precisão em microssegundos ou nanossegundos, use inteiros com o multiplicador apropriado.
Unix timestamps não consideram segundos intercalares. Um dia Unix tem sempre exatamente 86.400 segundos, mesmo que dias UTC reais ocasionalmente tenham 86.401 segundos. Para a maioria das aplicações, isso é irrelevante. Para aplicações científicas ou de satélites, use TAI (Tempo Atômico Internacional).
Armazene datas como timestamps (inteiro ou tipos datetime nativos) para ordenação, comparação e aritmética eficientes. Strings formatadas são mais difíceis de consultar e ordenar corretamente. A maioria dos bancos de dados possui tipos datetime nativos que lidam bem com isso. Reserve a formatação em string para exibição e respostas de API.
Um timestamp Unix (também chamado de hora epoch) é o número de segundos decorridos desde 00:00:00 UTC em 1 de janeiro de 1970, sem contar segundos bissextos. É um único inteiro que identifica inequivocamente qualquer momento no tempo, independente do fuso horário.
Os timestamps Unix tradicionais contam segundos inteiros. Linguagens e APIs modernas (JavaScript Date.now(), Java System.currentTimeMillis()) usam milissegundos — 1000× maior — para precisão sub-segundo. Ao interoperar, verifique sempre a magnitude: um número de 10 dígitos são segundos, de 13 dígitos são milissegundos.
Inteiros com sinal de 32 bits podem representar timestamps até 2.147.483.647, que corresponde a 03:14:07 UTC em 19 de janeiro de 2038. Após esse momento, sistemas de 32 bits transbordarão para valores negativos. Sistemas de 64 bits podem representar datas muito além do ano 292 bilhões.
Em JavaScript: new Date(ts * 1000).toISOString(). Em Python: datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(). Em SQL (PostgreSQL): to_timestamp(ts). O formato ISO 8601 é YYYY-MM-DDTHH:MM:SSZ para UTC, ex. 2024-01-15T12:30:00Z.