Convertidor de Timestamp Unix
Convierte un timestamp Unix (epoch) en una fecha legible —en tu hora local, UTC e ISO 8601— o transforma cualquier fecha de nuevo en un timestamp. Funciona en segundos o milisegundos.
—
Milisegundos: —
ISO 8601: —
Pega un valor epoch. Usa el selector si tu timestamp está en milisegundos.
Elige una fecha y hora para obtener su timestamp Unix.
Cómo usar Convertidor de Timestamp Unix
- 1
Introduce un timestamp
Pega o escribe un timestamp Unix en el campo «Timestamp a fecha» y cambia el selector Segundos / Milisegundos para que coincida con tu valor.
- 2
Lee la fecha
Consulta el momento en tu zona horaria local, en UTC, como cadena ISO 8601 y como tiempo relativo, por ejemplo «hace 3 horas».
- 3
Vuelve a convertir una fecha
Usa el selector «Fecha a timestamp» para elegir cualquier fecha y hora y obtener su valor epoch en segundos y milisegundos.
- 4
Copia el resultado
Haz clic en copiar en cualquier valor para llevarlo al portapapeles, listo para pegarlo en tu código, una consulta de base de datos o una petición de API.
El tiempo Unix, explicado para desarrolladores
Qué es un timestamp Unix
Un timestamp Unix es un único número que representa un instante en el tiempo: el recuento de segundos transcurridos desde el epoch de Unix, que es la medianoche UTC del 1 de enero de 1970. El timestamp 1700000000, por ejemplo, corresponde a las 22:13:20 UTC del 14 de noviembre de 2023. Un solo número captura la fecha y la hora completas sin ambigüedad.
Como no es más que un entero que cuenta hacia arriba, el tiempo Unix es trivial de almacenar, ordenar y comparar. Resta un timestamp de otro y obtienes el número exacto de segundos entre dos eventos. Esta sencillez es la razón por la que sustenta buena parte de la informática, desde las horas de modificación de archivos hasta los tokens de autenticación.
Por qué 1970
El epoch de 1970 es un vestigio histórico del sistema operativo Unix, que se estaba desarrollando en los Laboratorios Bell por aquella época. Los ingenieros necesitaban un punto de referencia fijo para el reloj del sistema, y el comienzo de la década en la que trabajaban era una opción limpia y cómoda. Cuajó, y décadas después sigue siendo el estándar en prácticamente todas las plataformas.
No hay nada matemáticamente especial en 1970; es sencillamente un punto cero compartido. Lo que importa es que todo el mundo esté de acuerdo en él. Esa referencia común es lo que permite que un timestamp generado en una máquina sea interpretado correctamente por cualquier otra, sin importar el fabricante, el lenguaje o la ubicación.
Segundos frente a milisegundos
El tiempo Unix tradicional se mide en segundos, pero muchos entornos modernos usan milisegundos para obtener una resolución más fina. Date.now de JavaScript, por ejemplo, devuelve milisegundos. La señal práctica es el número de dígitos: un timestamp actual en segundos tiene 10 dígitos, mientras que el mismo instante en milisegundos tiene 13 dígitos, aproximadamente mil veces mayor.
Mezclar las dos unidades es un error frecuente. Pasa un valor en milisegundos a una función que espera segundos y tu fecha aterrizará decenas de miles de años en el futuro; haz lo contrario y volverás a aterrizar cerca de 1970. Si una fecha convertida parece absurda, comprueba primero la unidad. El selector de Segundos y Milisegundos de esta herramienta existe precisamente para resolver esa confusión con un clic.
UTC frente a hora local
Un timestamp Unix en sí no lleva ninguna zona horaria. Marca el mismo instante en cualquier lugar de la Tierra; el número es idéntico tanto si estás en Tokio como en Nueva York. Las zonas horarias entran en juego solo cuando conviertes ese instante en una fecha legible para las personas, y por eso el mismo timestamp se muestra como horas de reloj distintas en lugares distintos.
Este convertidor muestra ambas formas: tu hora local, formateada con la zona horaria de tu dispositivo, y UTC, la referencia universal. Almacenar y transmitir los timestamps en UTC y convertirlos a la hora local solo para mostrarlos es la práctica estándar que evita toda una clase de errores de desfase horario, sobre todo en torno a los cambios de horario de verano.
El problema del año 2038
Muchos sistemas antiguos almacenan el tiempo Unix en un entero con signo de 32 bits, que puede contener un valor máximo de 2 147 483 647. Ese techo se alcanza a las 03:14:07 UTC del 19 de enero de 2038. Un segundo después, el contador se desborda y da la vuelta hasta un gran número negativo, que esos sistemas interpretan como una fecha allá por 1901.
Es el eco moderno del problema del año 2000, y amenaza a los dispositivos integrados, las bases de datos heredadas y todo código que todavía use tiempo de 32 bits. La solución es almacenar el tiempo en un entero más ancho de 64 bits, lo que empuja el límite cientos de miles de millones de años hacia adelante. Esta herramienta se ejecuta en tu navegador usando el manejo de fechas integrado de JavaScript en lugar del tiempo de 32 bits, así que convierte fechas mucho más allá de 2038 sin problema.
Convertir en ambos sentidos
Pasar de un timestamp a una fecha consiste en tratar el número como segundos desde el epoch e ir sumándolos. A la inversa, convertir una fecha en un timestamp calcula cuántos segundos hay entre el epoch y ese instante. El convertidor hace las dos cosas: pega un valor epoch para leer su fecha, o elige una fecha en el selector para obtener su timestamp.
La lectura de tiempo relativo, como «hace 3 horas», se obtiene restando el timestamp del momento actual y describiendo la diferencia en lenguaje llano. Resulta práctica para comprobar la verosimilitud de un valor de un vistazo, ya que una entrada de registro que afirma ser de dentro de dos años es a todas luces sospechosa.
Dónde te encontrarás el tiempo Unix
Los timestamps Unix están por todas partes en el software. Los registros de servidor marcan cada línea con uno para poder ordenar los eventos con precisión. Las API REST los devuelven en campos como created_at y expires_at porque son neutros respecto al lenguaje y compactos. Las bases de datos los usan para ordenar y para consultas por ventanas de tiempo, y los JWT codifican la caducidad como un timestamp Unix.
Para desarrolladores y analistas, leer estos valores con rapidez es una necesidad diaria. Cuando depuras una respuesta de API, revisas un archivo de registro o compruebas cuándo caduca un token, pegar el número en bruto en un convertidor transforma un entero opaco en una fecha sobre la que puedes razonar, tanto en tu hora local como en UTC, en segundos o en milisegundos.
Preguntas frecuentes
¿Qué es un timestamp Unix?
¿Mi timestamp está en segundos o en milisegundos?
¿Qué zona horaria usa el convertidor?
¿Qué es el problema del año 2038?
¿Se envían mis datos a un servidor?
Herramientas relacionadas
Sigue trabajando con estas prácticas herramientas