Conversor de timestamp Unix

¿Qué es un timestamp Unix?

Un timestamp Unix, también llamado tiempo Unix, hora POSIX o epoch, es el número de segundos que han pasado desde el 1 de enero de 1970 a las 00:00:00 UTC. Ese instante es «el epoch». Un segundo después el contador valía 1; un día después, 86 400.

El mismo instante tiene el mismo timestamp en cualquier lugar del mundo. Las zonas horarias y el cambio de hora solo entran en juego cuando conviertes el número en una fecha para que la lea una persona. Por eso lo adoran los servidores, las bases de datos, los logs y las API: un único número entero, sin zona horaria, fácil de ordenar y de restar.

¿Segundos o milisegundos?

La mayoría de los sistemas cuentan en segundos: hoy es un número de 10 cifras. JavaScript, Java y muchas API cuentan en milisegundos: 13 cifras. Algunas bases de datos y herramientas de trazas bajan hasta los microsegundos (16 cifras) o los nanosegundos (19 cifras).

El conversor de arriba mira la longitud del número y elige la unidad por ti. Si te sale una fecha de 1970 o muy lejos en el futuro, seguramente la unidad era otra: divide o multiplica por 1000.

El problema del año 2038

Muchos sistemas antiguos guardan el timestamp en un entero de 32 bits con signo. El valor más alto que cabe es 2 147 483 647, que corresponde al 19 de enero de 2038 a las 03:14:07 UTC. Un segundo después el contador se desborda y pasa a −2 147 483 648, y esos sistemas leen la fecha como el 13 de diciembre de 1901 a las 20:45:52.

Los sistemas modernos de 64 bits tienen margen para miles de millones de años. El riesgo está en los dispositivos embebidos, los formatos de archivo antiguos, las bases de datos con columnas de 32 bits y el código que convierte la hora en un entero de 32 bits. En Linux, las plataformas de 32 bits recibieron soporte para tiempo de 64 bits con el núcleo 5.6 en 2020 y con glibc 2.34 en 2021, pero el software tiene que recompilarse para aprovecharlo. Una buena prueba: guarda una fecha de 2040 y vuelve a leerla.

El tiempo Unix y los segundos intercalares

El tiempo Unix hace como si todos los días tuvieran exactamente 86 400 segundos. El reloj UTC real ha recibido 27 segundos intercalares desde 1972, el último el 31 de diciembre de 2016. Durante un segundo intercalar, el tiempo Unix suele repetir un segundo o estirar los segundos de alrededor, una técnica llamada «smearing» que usan algunos grandes proveedores de la nube. Así que un timestamp Unix no es una cuenta estricta de segundos transcurridos: es un número de días multiplicado por 86 400, más los segundos del día en curso.

En la práctica casi nunca importa, y cada vez importará menos. En noviembre de 2022, la Conferencia General de Pesas y Medidas decidió ampliar, como muy tarde en 2035, la diferencia permitida entre el UTC y la rotación de la Tierra, lo que en la práctica acaba con los segundos intercalares. El Servicio Internacional de Rotación de la Tierra ya ha anunciado que no habrá segundo intercalar a finales de diciembre de 2026.

Zonas horarias y cambio de hora

Un timestamp señala un instante, no la hora que marca un reloj. En el timestamp 1 700 000 000 eran las 23:13 en Madrid, las 22:13 en Canarias y en Londres, las 17:13 en Nueva York y las 16:13 en Ciudad de México: varias horas locales y un solo número. Para guardar fechas, quédate con el timestamp (o con una fecha ISO 8601 con «Z») y pasa a hora local solo para mostrarla.

El cambio de hora lo deja claro. La madrugada del último domingo de octubre, en la Península los relojes pasan de las 3:00 a las 2:00, así que la hora local entre las 2:00 y las 3:00 ocurre dos veces (en Canarias, entre la 1:00 y las 2:00). Una hora local sola es ambigua esa noche. Los timestamps, en cambio, siguen subiendo segundo a segundo sin ningún salto. El último domingo de marzo se salta una hora local, pero no falta ningún timestamp.

¿Timestamp o ISO 8601?

La ISO 8601 es la gemela legible del timestamp: 2023-11-14T22:13:20Z es el mismo instante que 1 700 000 000. El timestamp es compacto y fácil de comparar; la fecha ISO se lee fácilmente en un log o en un archivo JSON. Las dos son inequívocas siempre que la fecha ISO lleve «Z» o un desfase como +01:00.

Cómo obtener un timestamp Unix en código

// Hora Unix actual en segundos (Date.now() va en milisegundos)
Math.floor(Date.now() / 1000)

// De timestamp a fecha
new Date(1700000000 * 1000).toISOString()   // "2023-11-14T22:13:20.000Z"

// De fecha a timestamp
Date.UTC(2026, 0, 1) / 1000                  // 1767225600

import time
from datetime import datetime, timezone

int(time.time())                                       # hora Unix actual
datetime.fromtimestamp(1700000000, tz=timezone.utc)    # 2023-11-14 22:13:20+00:00
int(datetime(2026, 1, 1, tzinfo=timezone.utc).timestamp())   # 1767225600

time();                                   // hora Unix actual
gmdate('Y-m-d H:i:s', 1700000000);        // "2023-11-14 22:13:20"
strtotime('2026-01-01 00:00:00 UTC');     // 1767225600

-- MySQL (FROM_UNIXTIME usa la zona horaria de la sesión)
SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1700000000);

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM now())::bigint;
SELECT to_timestamp(1700000000);

-- SQLite
SELECT strftime('%s', 'now');
SELECT datetime(1700000000, 'unixepoch');

date +%s                              # hora Unix actual
date -u -d @1700000000                # Linux (date de GNU)
date -u -r 1700000000                 # macOS y BSD
date -u -d '2026-01-01 00:00' +%s     # 1767225600 (date de GNU)

Errores habituales

• La hora local sin querer. Crear una fecha a partir de «2026-01-01 00:00» sin zona usa la hora local del ordenador. Añade «Z» o «UTC», o usa el selector UTC de arriba, cuando quieras decir UTC. En invierno, en la Península, la diferencia es de una hora; en verano, de dos.
• Segundos leídos como milisegundos. Un número de 10 cifras leído en milisegundos cae en enero de 1970. Uno de 13 cifras leído en segundos cae decenas de miles de años en el futuro.
• Timestamps negativos. Las fechas anteriores a 1970 son números negativos: −86 400 es el 31 de diciembre de 1969. Casi todas las herramientas modernas los aceptan; algunas antiguas, no.

Para ver qué hora es un timestamp en otra ciudad, usa el conversor de zonas horarias. Para contar días entre dos fechas, la calculadora de fechas, y para duraciones en horas y minutos, la calculadora de horas.