Herramientas · Software

Conversor de timestamp Unix y fechas

Convierta una marca de tiempo Unix (época) a fecha y hora legible, o una fecha a época, en la zona horaria que elija. La herramienta detecta si el número está en segundos, milisegundos, microsegundos o nanosegundos, resuelve los cambios de horario de verano y trabaja en su navegador.

Conversión

Época actual: — segundos · — milisegundos

Dirección

Segundos, milisegundos, microsegundos o nanosegundos: la unidad se detecta por el tamaño del número.

Zona en la que se muestra la fecha o con la que se interpreta la fecha escrita.

Resultado

Escriba una marca de tiempo o elija una fecha para ver la conversión.

Estas herramientas se ejecutan en su navegador y no envían lo que usted escribe a nuestros servidores. Aun así, evite pegar secretos reales (contraseñas, claves privadas, tokens de producción) en cualquier sitio web. Consulte los Términos de uso.

Qué es el tiempo Unix (la época)

El tiempo Unix, o época (epoch), es una forma de representar un instante con un único número: la cantidad de segundos transcurridos desde las 00:00:00 UTC del 1 de enero de 1970, sin contar los segundos intercalares (cada día tiene siempre 86 400 segundos). Como es un simple número, se ordena, se resta y se almacena con facilidad, por lo que lo usan los sistemas operativos, las bases de datos, los registros de eventos, las API, los tokens JWT (iat, exp) y casi todos los lenguajes de programación.

Lo esencial es que una marca de tiempo no tiene zona horaria: identifica un instante único e idéntico en todo el mundo. La zona solo interviene al mostrarlo como fecha y hora para una persona, y es lo que esta herramienta le permite elegir.

Cómo usar el conversor

  1. Para pasar de época a fecha, elija Época → fecha, escriba el número (la unidad se detecta sola) y seleccione la zona horaria.
  2. Para pasar de fecha a época, elija Fecha → época, indique la fecha y la hora y la zona en que se expresan.
  3. Copie el resultado en segundos, en milisegundos o en formato ISO 8601. El botón Ahora rellena el instante actual.
  4. Revise las notas: avisan si la unidad es ambigua, si una hora cae en un cambio de horario de verano o si el instante supera el límite del año 2038.

Segundos, milisegundos, microsegundos y nanosegundos

Los sistemas no usan todos la misma unidad. La herramienta adivina cuál es según el tamaño del número, algo fiable para fechas entre 1973 y el año 5138:

UnidadCifras actualesEjemplo (el mismo instante)Dónde se ve
Segundos101700000000Unix y date +%s, JWT, PHP time(), MySQL UNIX_TIMESTAMP(), Python time.time() (con decimales).
Milisegundos131700000000000JavaScript Date.now(), Java System.currentTimeMillis(), muchas API y bases de datos.
Microsegundos161700000000000000Python datetime, PostgreSQL, trazas de Zipkin y Jaeger.
Nanosegundos191700000000000000000Go UnixNano(), InfluxDB, OpenTelemetry.

La detección es una heurística: un número pequeño como 86400000 puede ser 86 400 000 segundos (el año 1972) o 86 400 000 milisegundos (un día después del inicio de 1970). Si el resultado no tiene sentido, elija la unidad manualmente.

Valores de época notables

Época (segundos)Fecha y hora UTCQué es
01970-01-01T00:00:00ZEl inicio de la época Unix
86 4001970-01-02T00:00:00ZUn día después
1 000 000 0002001-09-09T01:46:40ZMil millones de segundos
1 234 567 8902009-02-13T23:31:30ZUna cifra curiosa, muy citada
1 700 000 0002023-11-14T22:13:20ZMil setecientos millones
2 000 000 0002033-05-18T03:33:20ZDos mil millones de segundos
2 147 483 6472038-01-19T03:14:07ZEl máximo de un entero de 32 bits con signo

Para mentalizarse con las escalas: 3600 son una hora, 86 400 un día, 604 800 una semana y 31 536 000 un año de 365 días.

Zonas horarias y horario de verano

Convertir una fecha local a época requiere conocer la zona, porque el mismo reloj de pared corresponde a instantes distintos según el lugar: las 10:30 en Costa Rica (UTC−6, sin horario de verano) y las 10:30 en Madrid (UTC+1 o UTC+2) son instantes separados por 7 u 8 horas. Esta herramienta usa la base de datos de zonas horarias IANA del navegador, que incluye todos los cambios de horario históricos.

El horario de verano crea dos situaciones delicadas, que la herramienta detecta y le explica:

SituaciónQué ocurreEjemplo en Nueva York, 2024Cómo se resuelve
Hora inexistente (hueco)Al adelantar el reloj, una hora entera no existe.10 de marzo, 02:30: el reloj pasa de las 02:00 a las 03:00.Se interpreta con el desfase anterior al cambio: 2024-03-10T07:30:00Z (equivale a las 03:30 locales).
Hora repetida (solapamiento)Al atrasar el reloj, una hora ocurre dos veces.3 de noviembre, 01:30: sucede en horario de verano y una hora después en horario estándar.Se toma la primera ocurrencia: 2024-11-03T05:30:00Z. La segunda sería 2024-11-03T06:30:00Z.

Por eso conviene guardar y transmitir siempre los instantes en UTC (o como época) y convertir a hora local solo al mostrarlos.

El problema del año 2038

Muchos sistemas antiguos guardan la época en un entero de 32 bits con signo, cuyo máximo es 2 147 483 647. Ese número corresponde al 19 de enero de 2038 a las 03:14:07 UTC. Un segundo después el valor desborda y pasa a ser negativo, de modo que el reloj saltaría al 13 de diciembre de 1901. Es el equivalente informático del «efecto 2000».

Afecta sobre todo a sistemas embebidos, firmware, formatos de archivo antiguos y bases de datos con columnas de 32 bits (por ejemplo, el tipo TIMESTAMP de MySQL llega hasta ese instante). La solución es usar enteros de 64 bits, que cubren unos 292 000 millones de años, y la mayoría de sistemas modernos ya los usan. La herramienta avisa cuando un instante supera ese límite.

Cómo obtener y convertir timestamps en código

Estas son las instrucciones habituales para trabajar con la época en distintos entornos:

// JavaScript
Date.now();                                    // milisegundos desde 1970
Math.floor(Date.now() / 1000);                 // segundos
new Date(1700000000 * 1000).toISOString();     // '2023-11-14T22:13:20.000Z'
Date.parse('2023-11-14T22:13:20Z') / 1000;     // 1700000000
# Python
import time, datetime
int(time.time())                                                          # segundos
datetime.datetime.fromtimestamp(1700000000, datetime.timezone.utc)        # 2023-11-14 22:13:20+00:00
datetime.datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc).timestamp()   # 1700000000.0
# Bash (GNU/Linux y macOS)
date +%s                    # segundos desde 1970
date -u -d @1700000000      # GNU/Linux: Tue Nov 14 22:13:20 UTC 2023
date -u -r 1700000000       # macOS y BSD
-- PostgreSQL
SELECT extract(epoch FROM now());     -- segundos, con decimales
SELECT to_timestamp(1700000000);      -- 2023-11-14 22:13:20+00
-- MySQL
SELECT UNIX_TIMESTAMP();              -- segundos
SELECT FROM_UNIXTIME(1700000000);     -- en la zona horaria de la sesión
// Java
long ms = System.currentTimeMillis();
Instant.ofEpochSecond(1700000000);    // 2023-11-14T22:13:20Z

// C#
DateTimeOffset.UtcNow.ToUnixTimeSeconds();
DateTimeOffset.FromUnixTimeSeconds(1700000000);

Errores frecuentes

  • Mezclar segundos y milisegundos. Si trata 1700000000 (segundos) como milisegundos obtiene el 20 de enero de 1970; si trata milisegundos como segundos, obtiene un año cercano al 55 000. Cuando una fecha salga en 1970, casi siempre es este error.
  • Guardar la hora local como si fuera UTC. Es la causa de los desfases de varias horas entre un servidor y un navegador. Convierta siempre con la zona correcta.
  • Ignorar el horario de verano. Sumar 24 horas (86 400 s) no equivale a «mañana a la misma hora» en un día con cambio de horario.
  • Usar números decimales para los milisegundos. Un float pierde precisión con valores de 13 cifras o más; use enteros de 64 bits.
  • Olvidar los valores negativos. Las fechas anteriores a 1970 tienen épocas negativas, que algunos sistemas no admiten.
  • Suponer que los segundos intercalares cuentan. El tiempo Unix los ignora: la diferencia entre dos épocas no incluye los 27 segundos intercalares añadidos desde 1972.

Si trabaja con tokens de sesión, la época aparece en las reclamaciones exp e iat de un JWT, que el decodificador JWT convierte automáticamente a fechas. Para programar tareas en horarios concretos, use el generador de expresiones cron.

Preguntas frecuentes

¿Qué es la época Unix?

Es el instante de referencia 1970-01-01 00:00:00 UTC. Un timestamp Unix cuenta los segundos (o milisegundos, etc.) transcurridos desde ese momento, sin contar los segundos intercalares.

¿Cómo sé si un timestamp está en segundos o milisegundos?

Mire el número de cifras: 10 cifras son segundos (1700000000), 13 son milisegundos, 16 microsegundos y 19 nanosegundos. La herramienta lo detecta automáticamente y le permite forzar la unidad si el resultado no cuadra.

¿Un timestamp depende de la zona horaria?

No. Representa un instante único en todo el mundo. La zona solo se aplica al mostrar el instante como fecha y hora local; el mismo timestamp se ve distinto en Costa Rica y en Madrid, pero es el mismo momento.

¿Por qué mi fecha aparece en 1970?

Porque el número está en segundos y se interpretó como milisegundos (o se dividió dos veces entre 1000). Un valor de 10 cifras tratado como milisegundos da una fecha de enero de 1970.

¿Qué ocurrirá en el año 2038?

Los sistemas que guardan el tiempo en un entero de 32 bits con signo desbordarán el 19 de enero de 2038 a las 03:14:07 UTC. Los sistemas actuales usan 64 bits y no se ven afectados; el riesgo está en software y dispositivos antiguos.

¿Cuántos segundos hay en un día, una semana y un año?

Un día tiene 86 400 segundos, una semana 604 800 y un año de 365 días 31 536 000 (31 622 400 en un año bisiesto). El tiempo Unix supone que todos los días tienen exactamente 86 400 segundos.

¿Se envían mis datos a algún servidor?

No. Las conversiones se hacen en su navegador con la base de datos de zonas horarias del propio navegador; lo que escribe no sale de su equipo.