¿El timestamp Unix depende de la zona horaria?

No. Un timestamp Unix cuenta segundos desde un instante fijo en UTC (1970-01-01T00:00:00Z), así que representa el mismo momento en cualquier lugar del mundo. La zona horaria solo interviene al mostrarlo como fecha y hora local.

¿Por qué mi timestamp se convierte en una fecha de 1970?

Casi siempre es una confusión de unidades: un valor en segundos interpretado como milisegundos queda a pocas semanas del epoch. En JavaScript, por ejemplo, new Date(1759672800) da enero de 1970, mientras que new Date(1759672800 * 1000) da la fecha correcta.

¿El tiempo Unix cuenta los segundos intercalares?

No. POSIX define que cada día tiene exactamente 86.400 segundos, así que los segundos intercalares no existen en tiempo Unix. Por eso no puede representarse un instante como 23:59:60, y varios proveedores de nube reparten ese segundo extra a lo largo del día (leap smearing) en lugar de insertarlo.

Conversor de timestamp Unix

Convierte timestamps Unix en segundos, milisegundos o nanosegundos a fecha legible en cualquier zona horaria, y fechas ISO 8601 a timestamp.

Qué es un timestamp Unix

Un timestamp Unix (también llamado epoch time o tiempo POSIX) es la cantidad de segundos transcurridos desde el 1 de enero de 1970 a las 00:00:00 UTC, un instante de referencia conocido como epoch. El valor 0 es exactamente ese momento; 1000000000 cayó el 9 de septiembre de 2001; los valores negativos representan fechas anteriores a 1970.

La gran ventaja de este formato es que identifica un instante sin ambigüedad: no depende de la zona horaria, del idioma ni del formato de fecha de cada país. 1759672800 es el mismo momento en Madrid, en Ciudad de México y en Tokio; lo único que cambia es cómo se muestra en cada reloj local. Por eso es el formato preferido para guardar fechas en bases de datos, registrar eventos en logs o intercambiar fechas entre sistemas.

Un detalle técnico: el tiempo Unix ignora los segundos intercalares. Cada día cuenta exactamente 86.400 segundos, lo que hace que la conversión entre timestamp y fecha sea una cuenta simple, a costa de no poder representar un instante como 23:59:60.

Segundos, milisegundos, microsegundos y nanosegundos

El timestamp "clásico" está en segundos, pero muchos lenguajes y sistemas usan unidades más finas. La forma más rápida de saber en qué unidad está un valor es contar sus dígitos: para fechas actuales, cada unidad agrega tres.

Unidad	Dígitos para una fecha actual	Ejemplo	Quién la usa
Segundos	10	`1759672800`	`date +%s`, PHP `time()`, Go `Unix()`, la mayoría de las APIs
Milisegundos	13	`1759672800000`	JavaScript `Date.now()`, Java `currentTimeMillis()`
Microsegundos	16	`1759672800000000`	PostgreSQL internamente, Python `time.time_ns() // 1000`
Nanosegundos	19	`1759672800000000000`	Go `UnixNano()`, Python `time.time_ns()`

La herramienta detecta la unidad automáticamente con esta misma regla (hasta 11 dígitos son segundos, de 12 a 14 milisegundos, de 15 a 17 microsegundos y 18 o más nanosegundos), y acierta para cualquier fecha entre 1973 y el año 5138. Si un caso especial no encaja, la unidad se puede fijar a mano en el selector.

Confundir segundos con milisegundos es probablemente el error más común al trabajar con timestamps: un valor en milisegundos interpretado como segundos cae unos 55.000 años en el futuro, y uno en segundos interpretado como milisegundos queda en enero de 1970.

Timestamps de referencia

Timestamp	Fecha y hora UTC	Por qué es conocido
`0`	1970-01-01 00:00:00	El epoch
`-1`	1969-12-31 23:59:59	El segundo anterior al epoch
`1000000000`	2001-09-09 01:46:40	El primer timestamp de 10 dígitos
`1234567890`	2009-02-13 23:31:30	Celebrado en su momento por la secuencia de dígitos
`1500000000`	2017-07-14 02:40:00
`2000000000`	2033-05-18 03:33:20	El próximo número redondo
`2147483647`	2038-01-19 03:14:07	Máximo de un entero de 32 bits con signo
`-2147483648`	1901-12-13 20:45:52	Mínimo de un entero de 32 bits con signo

El problema del año 2038

Durante décadas, muchos sistemas guardaron el timestamp en un entero de 32 bits con signo (el tipo time_t de C en plataformas de 32 bits). Ese tipo llega como máximo a 2147483647, que corresponde al 19 de enero de 2038 a las 03:14:07 UTC. Un segundo después, el valor se desborda y pasa a -2147483648, que se interpreta como 13 de diciembre de 1901.

Los sistemas operativos y lenguajes modernos ya usan 64 bits, que alcanzan para cientos de miles de millones de años. El riesgo está en lo que quedó atrás: equipos embebidos, formatos de archivo y protocolos con campos de 32 bits, y columnas de base de datos como el tipo TIMESTAMP de MySQL, cuyo rango termina justamente en 2038. La herramienta muestra un aviso cuando el instante convertido queda fuera del rango de 32 bits.

Formatos de salida

ISO 8601 / RFC 3339, como 2025-10-05T14:00:00Z. Es el formato recomendado para intercambiar fechas como texto: se ordena alfabéticamente igual que cronológicamente y siempre lleva la zona (Z para UTC o un desfase como -03:00).
En la zona elegida: el mismo instante expresado como hora local de una zona IANA (America/Bogota, Europe/Madrid), con el desfase que corresponde a esa fecha, incluido el horario de verano si aplica.
Fecha HTTP (RFC 9110), como Sun, 05 Oct 2025 14:00:00 GMT. Es el formato de las cabeceras Date, Expires y Last-Modified.
Relativo, como "hace 3 días" o "dentro de 2 horas", útil para entender rápidamente si un valor es reciente.

Cómo convertir una fecha en timestamp

El campo de fecha acepta ISO 8601 en sus formas más comunes: solo fecha (2025-10-05), fecha y hora (2025-10-05T14:00 o con espacio en lugar de la T), con segundos y milisegundos, y con zona explícita (Z, +02:00 o +0200). Cuando la fecha no indica zona, se interpreta como hora local de la zona seleccionada: 2025-10-05T09:00 en America/Bogota es el mismo instante que 2025-10-05T14:00Z. Esa regla evita la ambigüedad más frecuente al convertir fechas a mano, que es no saber en qué zona estaba escrita la hora original.

Las diferencias entre instante, hora local y desfase, y los errores que aparecen con el horario de verano, se explican en detalle en la guía Timestamps Unix y zonas horarias: cómo manejar fechas sin errores.

Obtener y convertir timestamps desde la terminal y el código

Entorno	Timestamp actual (segundos)	Timestamp a fecha
Bash (GNU)	`date +%s`	`date -d @1759672800`
macOS / BSD	`date +%s`	`date -r 1759672800`
JavaScript	`Math.floor(Date.now() / 1000)`	`new Date(1759672800 * 1000)`
Python	`int(time.time())`	`datetime.fromtimestamp(1759672800, tz=timezone.utc)`
PHP	`time()`	`date('c', 1759672800)`
Go	`time.Now().Unix()`	`time.Unix(1759672800, 0)`
Java	`Instant.now().getEpochSecond()`	`Instant.ofEpochSecond(1759672800)`
PostgreSQL	`extract(epoch from now())`	`to_timestamp(1759672800)`
MySQL	`UNIX_TIMESTAMP()`	`FROM_UNIXTIME(1759672800)`

En JavaScript conviene recordar que Date trabaja en milisegundos: multiplicar por 1000 al construir desde segundos y dividir al revés es la fuente de la mayoría de las fechas en 1970 que aparecen por error en una interfaz.

Privacidad

Toda la conversión ocurre en el navegador con la API Intl de JavaScript, que trae incorporada la base de datos de zonas horarias de IANA. Ningún valor se envía a un servidor; el timestamp solo se guarda en la URL para poder compartir el resultado.