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
| Unit | Digits | Example | Range approx. |
|---|---|---|---|
| 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 |
Las marcas de tiempo Unix son siempre UTC. No contienen información de zona horaria. Esto es en realidad una ventaja — proporciona un punto de referencia universal.
La confusión surge al convertir marcas de tiempo a fechas legibles para humanos:
const ts = 1700000000;
const date = new Date(ts * 1000);
date.toUTCString(); // "Tue, 14 Nov 2023 22:13:20 GMT"
date.toLocaleString(); // Depends on user's local time zone
date.toISOString(); // "2023-11-14T22:13:20.000Z"
Mejor práctica: Almacena y transmite marcas de tiempo en UTC. Convierte a hora local solo en la capa de visualización, lo más cerca posible del usuario.
-- Current timestamp
SELECT EXTRACT(EPOCH FROM NOW());
-- Timestamp to date
SELECT TO_TIMESTAMP(1700000000);
-- Date to timestamp
SELECT EXTRACT(EPOCH FROM '2023-11-14'::timestamp);
Si una fecha muestra enero de 1970, probablemente pasaste segundos donde se esperaban milisegundos (o viceversa). Siempre verifica qué precisión espera la API.
Al almacenar marcas de tiempo como números de punto flotante, puedes perder precisión más allá de milisegundos. Para precisión de microsegundos o nanosegundos, usa enteros con el multiplicador apropiado.
Las marcas de tiempo Unix no tienen en cuenta los segundos intercalares. Un día Unix siempre es exactamente 86,400 segundos, aunque los días UTC reales ocasionalmente tienen 86,401 segundos. Para la mayoría de las aplicaciones, esto es irrelevante. Para aplicaciones científicas o satelitales, usa TAI (Tiempo Atómico Internacional) en su lugar.
Almacena fechas como marcas de tiempo (enteros o tipos datetime nativos) para ordenación, comparación y aritmética eficientes. Las cadenas formateadas son más difíciles de consultar y ordenar correctamente. La mayoría de las bases de datos tienen tipos datetime nativos que manejan esto bien. Reserva el formateo de cadenas para visualización y respuestas de API.
Un Unix timestamp (también llamado tiempo epoch) es el número de segundos transcurridos desde las 00:00:00 UTC del 1 de enero de 1970, sin contar los segundos intercalares. Es un entero único que identifica sin ambigüedad cualquier momento en el tiempo, independientemente de la zona horaria.
Los Unix timestamps tradicionales cuentan segundos enteros. Los lenguajes y APIs modernos (Date.now() en JavaScript, System.currentTimeMillis() en Java) usan milisegundos —1000 veces mayor— para precisión sub-segundo. Al interoperar, comprueba siempre la magnitud: un número de 10 dígitos son segundos, uno de 13 son milisegundos.
Los enteros de 32 bits con signo pueden representar timestamps hasta 2.147.483.647, que corresponde a las 03:14:07 UTC del 19 de enero de 2038. Después de ese momento los sistemas de 32 bits se desbordarán a valores negativos. Los sistemas de 64 bits pueden representar fechas mucho más allá del año 292 mil millones.
En JavaScript: new Date(ts * 1000).toISOString(). En Python: datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(). En SQL (PostgreSQL): to_timestamp(ts). El formato ISO 8601 es AAAA-MM-DDTHH:MM:SSZ para UTC, p. ej. 2024-01-15T12:30:00Z.