Conversor de Timestamp Unix
Convierte timestamps Unix a fecha legible (ISO, UTC, hora local y relativa) y fechas a timestamp, con detección de segundos o milisegundos y reloj en vivo. Sin registro.
Timestamp actual
Tiempo Unix en vivo, se actualiza cada segundo.
——Timestamp → Fecha
Introduce un timestamp Unix y conviértelo a fecha legible.
Fecha → Timestamp
Elige una fecha y hora (en tu zona horaria) y obtén su timestamp Unix.
Todo se calcula en tu navegador; nada se envía a ningún servidor.
Qué hace esta herramienta
Traduce en las dos direcciones entre un timestamp Unix y una fecha legible:
- Timestamp → fecha: te da el instante en ISO 8601, en UTC, en tu hora local y en forma relativa (“hace 3 días”), además del día de la semana.
- Fecha → timestamp: eliges una fecha y una hora y obtienes el número, en segundos y en milisegundos.
Detecta sola si lo que pegas está en segundos o en milisegundos, y lleva un reloj en vivo con el timestamp de este momento para copiarlo de un clic.
Qué es exactamente un timestamp Unix
Es el número de segundos transcurridos desde las 00:00:00 UTC del 1 de enero de 1970. Esa fecha se llama la época Unix, la define POSIX y no tiene ningún significado especial: se eligió por ser un punto de partida redondo y cercano cuando se diseñó el sistema.
Su virtud es que es un entero. Un entero no tiene formato ambiguo (03/04/2026 es marzo en un país y abril en otro), no tiene idioma, no tiene zona horaria y ocupa lo mismo siempre. Por eso es lo que guardan las bases de datos, lo que viajan las APIs y lo que escriben los registros.
Su defecto es que un humano no puede leerlo, y de ahí esta página.
| Timestamp | Fecha en UTC |
|---|---|
0 | 1 de enero de 1970, 00:00:00 |
1000000000 | 9 de septiembre de 2001 |
1771200000 | 16 de febrero de 2026 |
2147483647 | 19 de enero de 2038, 03:14:07 |
El error de las tres ceros: segundos contra milisegundos
Es, con diferencia, el fallo más frecuente al trabajar con timestamps, y tiene un origen concreto: JavaScript cuenta en milisegundos y casi todo lo demás en segundos.
| Entorno | Unidad | Cómo se obtiene |
|---|---|---|
| JavaScript | milisegundos | Date.now() |
| PHP | segundos | time() |
| Python | segundos | int(time.time()) |
| MySQL | segundos | UNIX_TIMESTAMP() |
| PostgreSQL | segundos | EXTRACT(EPOCH FROM NOW()) |
| Terminal | segundos | date +%s |
| Java | milisegundos | System.currentTimeMillis() |
Cuando un dato cruza esa frontera sin convertirse, el síntoma es inconfundible:
- Te sale una fecha de enero de 1970. Tenías milisegundos y se leyeron como segundos: el número es tan pequeño en esa escala que cae al principio de la época.
- Te sale un año absurdo, tipo 58000. Tenías segundos y se leyeron como milisegundos… no, al revés: multiplicaste por mil sin querer, o pasaste segundos a una función que esperaba milisegundos y luego los volviste a multiplicar.
La regla rápida para saber qué tienes delante: cuenta los dígitos. Hoy, un timestamp en segundos tiene 10; en milisegundos, 13. Seguirá siendo así durante décadas.
En JavaScript la conversión es:
// segundos → objeto Date
new Date(1771200000 * 1000)
// Date → timestamp en segundos
Math.floor(Date.now() / 1000)
El Math.floor importa: sin él arrastras decimales que otras capas rechazan.
Por qué la hora “no cuadra”
Un timestamp no tiene zona horaria. Representa un instante absoluto, el mismo para todo el planeta. La zona horaria solo aparece al mostrarlo.
Eso significa que dos personas mirando el mismo número verán horas distintas y las dos estarán en lo cierto. Si en un registro ves 2026-02-16 10:00 y en tu pantalla sale 04:00, no hay ningún error: el registro está en UTC y tú estás en UTC−6.
Por eso esta herramienta enseña UTC y tu hora local a la vez, y te dice qué desfase tiene tu equipo. Cuando estés depurando un dato que “llega mal”, compara siempre contra el valor en UTC.
El corolario práctico, que ahorra muchas horas: guarda siempre en UTC y convierte solo al mostrar. Una base de datos con fechas en hora local es una base de datos que se rompe dos veces al año, cuando cambia el horario de verano.
El problema del año 2038
2147483647 es el mayor número que cabe en un entero de 32 bits con signo, y corresponde al 19 de enero de 2038 a las 03:14:07 UTC.
Un segundo después, un sistema que guarde el timestamp en 32 bits desborda: el número pasa a negativo y se interpreta como el 13 de diciembre de 1901. Es el mismo tipo de fallo que el efecto 2000, pero con una fecha exacta y conocida.
A quién afecta todavía:
- Software antiguo en C que usa
time_tde 32 bits. - Bases de datos con columnas
TIMESTAMPde 32 bits — en MySQL es el caso deTIMESTAMP, que llega hasta 2038, mientras queDATETIMEllega a 9999. - Sistemas empotrados y dispositivos que no se actualizan.
La solución es usar 64 bits, que es lo que hacen ya los sistemas operativos modernos y lo que da margen hasta dentro de unos 292 mil millones de años. Si tu columna de MySQL es TIMESTAMP y guardas fechas futuras (vencimientos, contratos, suscripciones a largo plazo), el problema no es de 2038: es de ahora, porque una fecha de 2040 ya no entra.
Casos en los que se usa esto a diario
- Leer un registro o una traza donde el error viene sellado con un número.
- Comprobar la expiración de un JWT: el campo
expes un timestamp Unix, y aquí sale la fecha. El decodificador de JWT hace la lectura completa del token. - Depurar una respuesta de API que devuelve
created_atcomo entero. - Escribir una consulta SQL con un rango de fechas convertido a timestamps.
- Programar una tarea y comprobar a qué instante corresponde.
Preguntas frecuentes
¿Qué es un timestamp Unix?
Es el número de segundos transcurridos desde las 00:00:00 UTC del 1 de enero de 1970, la fecha que se conoce como época Unix. Es la forma más común de guardar un instante en bases de datos, APIs y registros, porque es un entero: no depende del idioma, ni del formato de fecha del país, ni de la zona horaria de quien lo lea. El inconveniente es que un humano no puede leerlo, y de ahí esta herramienta.
¿Mi número está en segundos o en milisegundos?
Por la longitud. Un timestamp en segundos tiene 10 dígitos hoy en día (por ejemplo 1771200000); en milisegundos tiene 13 (1771200000000). La regla práctica: si al convertirlo te sale una fecha de 1970 es que estaba en milisegundos y se ha leído como segundos, y si te sale un año imposible como 58000 es lo contrario. JavaScript trabaja en milisegundos y casi todo lo demás —PHP, Python, MySQL, la mayoría de APIs— en segundos, y ese desajuste es la causa número uno del problema. La herramienta lo detecta automáticamente.
¿Por qué la fecha que obtengo tiene unas horas de diferencia?
Porque un timestamp no tiene zona horaria: siempre representa un instante en UTC. La diferencia aparece al mostrarlo, cuando se convierte a la hora local de quien mira. Por eso la herramienta enseña las dos a la vez, UTC y tu hora local, y te dice qué desfase tiene tu equipo. Si estás depurando un dato que "llega mal", compara siempre contra el valor en UTC: ahí es donde está la verdad.
¿Qué es el problema del año 2038?
Los sistemas que guardan el timestamp en un entero de 32 bits con signo se quedan sin espacio el 19 de enero de 2038 a las 03:14:07 UTC. Un segundo después el número desborda y pasa a ser negativo, que se interpreta como diciembre de 1901. Afecta a software antiguo en C, a algunas bases de datos con columnas TIMESTAMP de 32 bits y a sistemas empotrados. La solución es usar 64 bits, que es lo que hacen ya los sistemas modernos y lo que aguanta unos 292 mil millones de años.
¿Cómo obtengo el timestamp actual en mi lenguaje?
En PHP con time() para segundos. En JavaScript con Date.now(), que da milisegundos, así que hay que dividir entre 1000 y redondear si necesitas segundos. En Python con int(time.time()). En MySQL con UNIX_TIMESTAMP(). En PostgreSQL con EXTRACT(EPOCH FROM NOW()). En la terminal con date +%s. Todos devuelven el mismo instante; lo único que cambia es la unidad.
Reseñas y valoraciones
Aún no hay reseñas. ¡Sé la primera persona en opinar!
Guías relacionadas
Tutoriales del blog donde esta herramienta resulta útil.
Herramientas relacionadas
Otras del catálogo que se usan bien junto a esta.