Unix Timestamp explicado: Guía completa de la hora Epoch

Si alguna vez has depurado una respuesta de API, configurado un log de servidor o trabajado con bases de datos, probablemente te has encontrado con un timestamp Unix. Estas largas secuencias numéricas como 1700000000 parecen crípticas a primera vista, pero en realidad son una de las formas más simples y universales de representar un momento en el tiempo.

Esta guía explica qué son los timestamps Unix, cómo funciona la hora epoch y cómo convertir entre timestamps y fechas legibles — con ejemplos prácticos que puedes usar de inmediato.

¿Qué es un Unix Timestamp?

Un timestamp Unix es un número que representa el total de segundos transcurridos desde el 1 de enero de 1970 a las 00:00:00 UTC. Este punto de partida se llama el epoch Unix.

Por ejemplo, el timestamp 1700000000 corresponde al 14 de noviembre de 2023 a las 22:13:20 UTC. En lugar de manejar años, meses, días, horas, minutos y segundos por separado, un timestamp condensa todo en un solo entero.

También conocido como hora Unix, hora epoch u hora POSIX, este sistema se utiliza en prácticamente todos los lenguajes de programación, sistemas operativos y bases de datos.

El Epoch Unix explicado

El epoch Unix es el jueves 1 de enero de 1970, 00:00:00 UTC — el momento a partir del cual todos los timestamps Unix comienzan a contar.

¿Por qué 1970? Cuando Unix fue desarrollado en los Bell Labs a principios de los años 70, los creadores necesitaban un punto de referencia. El 1 de enero de 1970 fue elegido como una fecha de inicio práctica: lo suficientemente reciente para ser relevante, y convenientemente al comienzo de un año.

Cada segundo transcurrido desde ese momento suma uno al timestamp. Actualmente hemos superado los 1.760 millones de segundos desde el epoch.

Segundos vs milisegundos

Una de las fuentes de confusión más comunes es la diferencia entre segundos y milisegundos:

Precisión	Dígitos	Ejemplo	Usado por
Segundos	10	1700000000	Python, PHP, la mayoría de APIs
Milisegundos	13	1700000000000	JavaScript, Java, muchas APIs web

Regla práctica: Si tu timestamp tiene 10 dígitos, está en segundos. Si tiene 13 dígitos, está en milisegundos. Para convertir, multiplica o divide entre 1.000.

Cómo convertir un Unix Timestamp a fecha

Convertir un timestamp a una fecha legible es sencillo con las herramientas adecuadas.

Con nuestro conversor: Introduce el timestamp en nuestro Conversor de Unix Timestamp y obtén la fecha al instante.

En código:

// JavaScript (espera milisegundos)
const fecha = new Date(1700000000 * 1000);
console.log(fecha.toISOString());
// Resultado: "2023-11-14T22:13:20.000Z"

# Python
import datetime
fecha = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)
print(fecha.isoformat())
# Resultado: "2023-11-14T22:13:20+00:00"

// PHP
echo date('Y-m-d H:i:s', 1700000000);
// Resultado: "2023-11-14 22:13:20"

Cómo convertir una fecha a Unix Timestamp

La operación inversa — convertir una fecha a timestamp — es igualmente frecuente.

// JavaScript
const timestamp = Math.floor(
  new Date("2024-01-15T12:00:00Z").getTime() / 1000
);
console.log(timestamp); // 1705320000

# Python
import datetime
dt = datetime.datetime(2024, 1, 15, 12, 0, 0, tzinfo=datetime.timezone.utc)
print(int(dt.timestamp()))  # 1705320000

// PHP
echo strtotime("2024-01-15T12:00:00+00:00");
// Resultado: 1705320000

Ejemplos de Unix Timestamp

Aquí tienes algunos timestamps notables como referencia:

Timestamp	Fecha (UTC)	Significado
0	1 ene. 1970 00:00:00	El epoch Unix
1000000000	9 sept. 2001 01:46:40	El milmillonésimo segundo
1234567890	13 feb. 2009 23:31:30	Un valor de prueba popular
1700000000	14 nov. 2023 22:13:20	Un número redondo reciente
2000000000	18 mayo 2033 03:33:20	Un hito futuro
2147483647	19 ene. 2038 03:14:07	Valor máximo con signo de 32 bits

Formatos de timestamp comunes

Los timestamps Unix son solo una forma de representar fechas. Así se ve el mismo momento en diferentes formatos:

Formato	Ejemplo
Unix timestamp	1700000000
ISO 8601	2023-11-14T22:13:20Z
RFC 2822	Tue, 14 Nov 2023 22:13:20 +0000
RFC 3339	2023-11-14T22:13:20+00:00
Legible	14 de noviembre de 2023 22:13:20

ISO 8601 es el formato más utilizado en APIs y sistemas modernos. El sufijo Z significa «hora Zulu» (UTC).

Unix Timestamp en programación

Cada lenguaje importante proporciona soporte integrado para trabajar con timestamps.

JavaScript

// Timestamp actual (milisegundos — dividir entre 1000 para segundos)
const ahora = Math.floor(Date.now() / 1000);

// Timestamp a fecha
const fecha = new Date(1700000000 * 1000);

// Fecha a timestamp
const ts = Math.floor(new Date("2024-06-15").getTime() / 1000);

Python

import datetime

# Timestamp actual
ahora = int(datetime.datetime.now().timestamp())

# Timestamp a fecha
fecha = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)

# Fecha a timestamp
ts = int(datetime.datetime(2024, 6, 15, tzinfo=datetime.timezone.utc).timestamp())

PHP

// Timestamp actual
$ahora = time();

// Timestamp a fecha
echo date('Y-m-d H:i:s', 1700000000);

// Fecha a timestamp
$ts = strtotime("2024-06-15");

Errores comunes

1. Confundir segundos y milisegundos El error más frecuente. El Date.getTime() de JavaScript devuelve milisegundos, mientras que time.time() de Python devuelve segundos. Verifica siempre qué unidad espera tu herramienta — un número de 13 dígitos significa milisegundos.

2. Ignorar las zonas horarias Los timestamps Unix siempre están en UTC. Si muestras un timestamp sin especificar zona horaria, se muestra en UTC por defecto. Usa las funciones de localización de tu lenguaje para convertir a la hora local.

3. El problema del año 2038 El 19 de enero de 2038, los timestamps con signo de 32 bits se desbordarán (2.147.483.647 es el valor máximo). La mayoría de los sistemas modernos usan enteros de 64 bits, así que no es un problema práctico — pero vale la pena saberlo si trabajas con sistemas antiguos.

4. Olvidar los segundos intercalares Los timestamps Unix ignoran los segundos intercalares. Cada día se trata como exactamente 86.400 segundos. Para la mayoría de aplicaciones esto no importa, pero los sistemas de alta precisión deben tenerlo en cuenta.

Prueba nuestro conversor gratuito

¿Necesitas convertir rápidamente un timestamp a fecha — o viceversa? Nuestro Conversor de Unix Timestamp maneja ambas direcciones al instante. Introduce un valor, obtén tu resultado y cópialo con un clic.

Es perfecto para depurar respuestas API, verificar entradas de base de datos o convertir timestamps de archivos de log. También puedes consultar nuestra guía ¿Qué es un Timestamp? para más información.

Preguntas frecuentes

¿Qué es un Unix timestamp? Un Unix timestamp es el número de segundos transcurridos desde el 1 de enero de 1970 (el epoch Unix). Es una forma universal e independiente de la zona horaria de representar cualquier momento como un solo entero.

¿Cómo obtengo el Unix timestamp actual? En JavaScript: Math.floor(Date.now() / 1000). En Python: int(time.time()). En PHP: time(). Todos devuelven los segundos actuales desde el epoch.

¿Por qué JavaScript usa milisegundos? El objeto Date de JavaScript fue diseñado para precisión de milisegundos, útil para aplicaciones web. Multiplica los segundos por 1.000 o divide los milisegundos entre 1.000 para convertir.

¿Los Unix timestamps se ven afectados por las zonas horarias? No. Los timestamps siempre están en UTC. Las zonas horarias solo importan cuando conviertes un timestamp a una fecha legible para mostrarla.

¿Qué pasa después del año 2038? Los timestamps con signo de 32 bits se desbordan el 19 de enero de 2038. Los sistemas modernos de 64 bits pueden representar fechas durante miles de millones de años, así que no es un problema práctico para el software actual.

¿Cómo convierto milisegundos a segundos? Divide entre 1.000. Por ejemplo, 1700000000000 milisegundos equivalen a 1700000000 segundos.

Conclusión

Los Unix timestamps son un concepto fundamental en la informática. Proporcionan una forma simple y universal de representar el tiempo que funciona en todos los lenguajes, plataformas y bases de datos. Ya sea que estés convirtiendo timestamps en código, depurando archivos de log o simplemente tienes curiosidad por saber qué significa 1700000000, entender la hora epoch es una habilidad esencial para cualquier desarrollador.

Guarda en favoritos nuestro Conversor de Unix Timestamp para conversiones rápidas, y consulta el Calculadora de diferencia de fechas y la Calculadora de edad para más herramientas relacionadas con fechas.