Timestamps Unix: cómo funcionan y dónde suelen fallar
Números como 1795226400 aparecen en logs de servidores, bases de datos y respuestas de APIs. Esta guía explica cómo leerlos, por qué el mismo número es correcto en Madrid y en Ciudad de México, y dónde se suelen romper las conversiones.
Segundos contados desde 1970
Un timestamp Unix es el número de segundos transcurridos desde el epoch, el 1 de enero de 1970 a las 00:00:00 UTC. POSIX lo define con una fórmula de calendario en la que cada día cuenta exactamente 86.400 segundos. Por ejemplo, 1795226400 es el 21 de noviembre de 2026 a las 02:00:00 UTC, que en la España peninsular fueron las 3:00 y en Ciudad de México las 20:00 del día 20. Los instantes anteriores a 1970 son negativos: -86400 es el 31 de diciembre de 1969 a las 00:00 UTC.
Como es un solo entero, se guarda, se compara y se resta con facilidad: la diferencia entre dos timestamps es el tiempo entre ellos en segundos, sin meses ni años bisiestos de por medio.
Segundos o milisegundos
Muchos sistemas guardan el epoch en unidades más finas, y el número de cifras lo delata. Para cualquier fecha entre el 9 de septiembre de 2001 y el 20 de noviembre de 2286, un timestamp en segundos tiene exactamente 10 cifras:
| Unidad | Cifras | 2026-11-21 02:00 UTC |
|---|---|---|
| Segundos | 10 | 1795226400 |
| Milisegundos | 13 | 1795226400000 |
| Microsegundos | 16 | 1795226400000000 |
| Nanosegundos | 19 | 1795226400000000000 |
Date.now() de JavaScript y System.currentTimeMillis() de Java dan milisegundos; time() de PHP, segundos; time.time() de Python, segundos con decimales, y UnixNano() de Go, nanosegundos. Confundirlos es el fallo más común. Milisegundos leídos como segundos caen en el año 58858, y segundos leídos como milisegundos, el 21 de enero de 1970. Una fecha que aparece en enero de 1970 casi siempre significa que las unidades están cambiadas.
Un timestamp no tiene zona horaria
Un timestamp señala el mismo instante en todo el planeta. La zona horaria solo entra en juego al mostrar ese instante como hora de reloj. 1795226400 son las 3:00 del 21 de noviembre en Madrid, las 2:00 en Canarias, las 21:00 del día 20 en Bogotá y las 20:00 en Ciudad de México. El horario de verano cambia la diferencia entre esas ciudades dos veces al año, pero nunca el timestamp. Ciudad de México, además, está en UTC−6 todo el año desde que la Ley de los Husos Horarios de 2022 suprimió el horario de verano en la mayor parte del país.
La regla de trabajo: guarda las horas como timestamps o en UTC, y conviértelas a la zona del usuario solo para mostrarlas. Usa nombres de zona IANA como Europe/Madrid o America/Bogota en lugar de un desfase fijo como +1, para que las reglas del horario de verano se apliquen solas. Una hora local que cae en el salto de primavera nunca existió: en la España peninsular, el 29 de marzo de 2026 el reloj pasó de las 2:00 a las 3:00, así que las 2:30 de ese día no existieron, y cada biblioteca lo resuelve a su manera, a menudo moviéndola una hora sin avisar.
Cuidado con las fechas sin zona. En JavaScript, new Date('2026-11-21') se lee como medianoche UTC, pero new Date('2026-11-21T09:00') como hora local del dispositivo.
Segundos intercalares
UTC añade de vez en cuando un segundo intercalar para no alejarse de la rotación de la Tierra. Ha habido 27 desde 1972; el último fue a las 23:59:60 UTC del 31 de diciembre de 2016. El tiempo Unix los ignora, porque cada día cuenta 86.400 segundos, así que dos timestamps a ambos lados del final de 2016 se diferencian en un segundo menos del tiempo real. Cuando llega uno, los sistemas repiten un segundo o lo reparten; los servidores NTP públicos de Google ralentizan su reloj durante 24 horas.
No hay ninguno más previsto: el Boletín C del IERS de julio de 2026 no anunció ninguno para finales de 2026, y en 2022 la Conferencia General de Pesas y Medidas decidió ampliar, en 2035 o antes, la diferencia permitida entre UT1 y UTC.
El problema del año 2038
Los sistemas antiguos guardan los timestamps como un entero de 32 bits con signo, cuyo máximo es 2.147.483.647: el 19 de enero de 2038 a las 03:14:07 UTC. Un segundo después el valor salta a −2.147.483.648, que se lee como el 13 de diciembre de 1901. Sin signo, 32 bits llegan al 7 de febrero de 2106; con 64 bits el límite deja de importar.
La columna TIMESTAMP de MySQL solo llega a 2038-01-19 03:14:07 UTC, mientras que DATETIME llega al año 9999. Y el problema no espera a 2038: una hipoteca a 15 años firmada hoy termina en 2041.
Convertir en lenguajes habituales
JavaScript:
Math.floor(Date.now() / 1000) // ahora
const d = new Date(1795226400 * 1000);
d.toISOString();
// '2026-11-21T02:00:00.000Z'
d.toLocaleString('es-ES',
{ timeZone: 'Europe/Madrid' });
// '21/11/2026, 3:00:00'
Date.parse('2026-11-21T03:00:00+01:00')
/ 1000; // 1795226400
Python 3.9 o posterior:
from datetime import datetime
from zoneinfo import ZoneInfo
mad = ZoneInfo('Europe/Madrid')
datetime.fromtimestamp(1795226400, mad)
# 2026-11-21 03:00:00+01:00
dt = datetime(2026, 11, 21, 3, 0,
tzinfo=mad)
int(dt.timestamp()) # 1795226400
PHP, SQL y la terminal:
// PHP
$d = new DateTime('@1795226400');
$d->setTimezone(
new DateTimeZone('Europe/Madrid'));
echo $d->format('c');
// 2026-11-21T03:00:00+01:00
-- PostgreSQL
SELECT to_timestamp(1795226400);
-- MySQL, usa la zona de la sesión
SELECT FROM_UNIXTIME(1795226400);
date +%s # ahora
date -u -d @1795226400 # Linux
date -u -r 1795226400 # macOS
Convertir en swift.id
- Abre el Conversor de timestamp Unix. Arriba verás el Timestamp Unix actual (segundos) y el valor En milisegundos, cada uno con su botón Copiar.
- Pega un número en Timestamp Unix. Con la Unidad en Automática, los valores por debajo de 1011 se leen como segundos, por debajo de 1014 como milisegundos, por debajo de 1017 como microsegundos y el resto como nanosegundos. Elige tú la unidad si se equivoca.
- Lee el resultado como hora local, UTC, ISO 8601, RFC 2822 o tiempo relativo, y copia la línea que necesites.
- Para el sentido contrario, rellena Fecha y Hora en Fecha a timestamp y elige la Zona horaria; la lista incluye la España peninsular, Canarias, México, Colombia, Perú, Chile y Argentina. Si la hora cae en un salto o un solapamiento del horario de verano, la herramienta lo avisa y dice qué instante ha usado.
Los timestamps también se esconden dentro de los UUID de versión 7; la guía de UUID v4 y v7 explica cómo leerlos.
Preguntas frecuentes
¿Por qué la hora convertida sale desfasada varias horas?
¿Puede ser negativo un timestamp?
¿JavaScript está a salvo del problema de 2038?
Date de JavaScript guarda milisegundos en un número de coma flotante de 64 bits y llega al año 275760. El problema aparece cuando ese valor va a una columna de base de datos u otro programa que sigue siendo de 32 bits.¿Una API debe usar timestamps o fechas ISO 8601?
created_at_ms. Una fecha ISO 8601 necesita su desfase, como 2026-11-21T03:00:00+01:00, o el sufijo Z para UTC.