Menu

Conversor de Unix Timestamp

Convierte entre marcas Unix, ISO 8601, UTC y hora local.

Última actualización

Unidad
Ahora
EntradaMarca de tiempo válida
SalidaToca un valor para copiarlo
  • Unix (s)1777239893
  • Unix (ms)1777239893000
  • ISO 8601 (UTC)2026-04-26T21:44:53.000Z
  • Local2026-04-26 21:44:53
  • UTCSun, 26 Apr 2026 21:44:53 GMT
  • Relativo

¿Qué es un conversor de Unix timestamp?

Un conversor de Unix timestamp transforma el *epoch time* — un único número que representa un instante concreto — en fechas legibles, y vuelve a convertir esas fechas en timestamps. Como desarrollador los ves en todas partes: columnas de bases de datos, líneas de log, respuestas de APIs, eventos de analítica, el claim exp de un JWT, disparadores de tareas programadas o cabeceras de expiración de caché.

La idea es sencilla: los ordenadores guardan el tiempo como un número (segundos o milisegundos desde 1970-01-01 00:00:00 UTC), pero las personas necesitamos calendarios, zonas horarias y formatos legibles. Convertir entre ambos mundos es una de las tareas de depuración más habituales en cualquier app web o móvil.

La parte más confusa son las *unidades*. POSIX y la mayoría de lenguajes de backend usan segundos. JavaScript, Java y muchos brokers de mensajería usan milisegundos. Algunos sistemas de métricas usan microsegundos o nanosegundos. Un número de 10 dígitos casi siempre son segundos; uno de 13 dígitos casi siempre son milisegundos.

Lo que vas a aprender convirtiendo timestamps

  • Los Unix timestamps miden el tiempo en *segundos* o *milisegundos* desde el epoch de Unix (1970-01-01 00:00:00 UTC).
  • UTC es una referencia fija. La hora local depende de la zona horaria del usuario, las reglas de horario de verano y la configuración del reloj del dispositivo.
  • ISO 8601 (2026-04-25T12:00:00Z) es un formato de texto portable. La Z final (o +00:00) significa UTC; un offset como +02:00 indica una hora local que va 2 horas por delante de UTC.

Cómo convertir un Unix timestamp paso a paso

  1. Pega el valor

    Pega un número (segundos o milisegundos) o una cadena de fecha. El conversor detecta el formato automáticamente según su longitud y forma.

  2. Confirma la unidad

    Cambia entre segundos y milisegundos si la detección automática se equivoca: 10 dígitos son segundos, 13 dígitos son milisegundos.

  3. Lee ambas vistas

    La salida muestra ISO 8601 en UTC, tu hora local y una expresión relativa legible (hace 3 horas, dentro de 2 días).

  4. Copia lo que necesites

    Copia el timestamp, la cadena ISO o la hora local directamente. Útil para rellenar el exp de un JWT, una fila de la base de datos o una consulta a logs.

Referencia rápida de formatos de timestamp

Los formatos que más vas a ver al trabajar con fechas y horas en código. ISO 8601 también está descrito por la IETF como RFC 3339 para su uso en protocolos.

FormatoEjemploDónde aparece
Unix en segundos1777118400Logs de backend, exp de JWT, time() de POSIX, Redis
Unix en milisegundos1777118400000Date.now() de JavaScript, System.currentTimeMillis() de Java
ISO 8601 en UTC2026-04-25T12:00:00ZAPIs REST, JSON, GraphQL, ficheros de log
ISO 8601 con offset2026-04-25T14:00:00+02:00Programación visible para el usuario, invitaciones de calendario
RFC 2822Sat, 25 Apr 2026 12:00:00 GMTCabeceras de correo, Date y Last-Modified en HTTP
Solo fecha2026-04-25Cumpleaños, festivos: sin información de zona horaria

Ejemplos de timestamps para probar

Segundos vs milisegundos

Segundos (10 dígitos)

1777118400

Milisegundos (13 dígitos)

1777118400000

Ambos valores representan el mismo instante si el primero se interpreta como segundos y el segundo como milisegundos. Confundirlos es el bug más típico al trabajar con timestamps.

Leer un timestamp de una API

Respuesta
{  "id": 42,  "createdAt": 1777118400,  "expiresAt": 1777204800}

Convierte cada valor antes de dar por hecho si está en el pasado o en el futuro. La mayoría de APIs JSON usan Unix en segundos, pero siempre revisa la documentación: los backends muy basados en JavaScript suelen emitir milisegundos.

Comparar UTC y hora local

UTC

2026-04-25T12:00:00Z

Mismo instante, +02:00

2026-04-25T14:00:00+02:00

Estas dos cadenas representan el *mismo instante*. Guarda siempre los momentos en UTC y formatea a hora local solo al mostrarlos.

Errores típicos con timestamps

  • Mezclar segundos y milisegundos. Un factor de 1000 puede mover una fecha décadas: 1700000000 leído como segundos es noviembre de 2023, pero leído como milisegundos es enero de 1970.
  • Guardar una cadena de fecha sin zona horaria. Cada sistema la interpretará a su manera: unos asumen UTC, otros asumen la zona local del servidor.
  • Comparar cadenas de fecha formateadas ('2026-04-25') en lugar de comparar timestamps. Dos cadenas ISO válidas pueden describir el mismo instante con formatos distintos.

Preguntas frecuentes sobre Unix timestamps

¿Qué es un Unix timestamp?
Un Unix timestamp (también llamado epoch time) es el número de segundos (o milisegundos) transcurridos desde 1970-01-01 00:00:00 UTC. Es un único número que representa un instante concreto, sin depender de ninguna zona horaria.
¿Por qué unos timestamps tienen 10 dígitos y otros 13?
Un Unix timestamp de 10 dígitos está en segundos. Uno de 13, en milisegundos. Date.now() de JavaScript devuelve milisegundos; la mayoría de backends devuelven segundos.
¿Qué significa UTC?
UTC son las siglas de Coordinated Universal Time (Tiempo Universal Coordinado). Es el estándar global de referencia horaria y no aplica horario de verano. La mayoría de bases de datos, APIs y logs deberían guardar la hora en UTC.
¿Por qué JavaScript usa milisegundos?
El objeto Date de JavaScript guarda los timestamps como milisegundos desde el epoch de Unix: ese es el valor que devuelven Date.now() y new Date().getTime(). Ofrece más precisión que los segundos, pero es una fuente habitual de bugs por factor 1000 al integrarse con otros lenguajes.
¿Cómo convierto un Unix timestamp a fecha?
Multiplica por 1000 (si está en segundos) y pásalo a new Date(...) en JavaScript, o usa datetime.fromtimestamp(...) en Python. O pégalo en un conversor de Unix timestamp para obtener el resultado en un clic.
¿Los Unix timestamps pueden desbordarse?
Los Unix timestamps con signo de 32 bits se desbordan el 2038-01-19: es el famoso problema del año 2038. Los lenguajes y bases de datos modernos guardan los timestamps en enteros de 64 bits, lo que extiende el rango seguro durante cientos de miles de millones de años.

Más información

Otras herramientas para desarrolladores

Aprende a programar con Coddy

COMENZAR