Conversor de marca de tiempo Unix a fecha

¿Qué es un timestamp Unix?

Un timestamp Unix, también llamado Unix time o POSIX time, es la cantidad de segundos que han transcurrido desde 1970-01-01 00:00:00 UTC, conocido como Unix epoch. Es un estándar muy usado en computación porque representa un momento en el tiempo como un único número entero, lo que hace que el almacenamiento, la comparación y los cálculos sean sencillos.

JavaScript trabaja internamente en milisegundos, por lo que Date.now() devuelve el timestamp Unix multiplicado por 1000. Muchas API, bases de datos y sistemas backend usan segundos en su lugar. Esta herramienta acepta ambos formatos y detecta automáticamente si ingresaste segundos o milisegundos según el tamaño del número.

Timestamps Unix destacados

Timestamp	Fecha (UTC)	Nota
0	1970-01-01 00:00:00	Unix epoch
1,000,000,000	2001-09-09 01:46:40	1.000 millones de segundos
2,000,000,000	2033-05-18 03:33:20	2.000 millones de segundos
2,147,483,647	2038-01-19 03:14:07	Problema del año 2038 (máx. 32-bit)

¿Por qué 1970?

El Unix epoch del 1 de enero de 1970 se eligió en parte por convención y en parte por limitaciones prácticas. Unix se desarrolló a finales de los años 60 y principios de los 70 en Bell Labs. Sus desarrolladores necesitaban una fecha de inicio reciente y “redonda” para representar el tiempo. El 1 de enero de 1970 era lo suficientemente reciente como para ser práctico y no tenía un significado técnico especial: simplemente era un punto de anclaje conveniente.

Existen otras fechas de epoch en otros sistemas: Windows FILETIME usa el 1 de enero de 1601; el tiempo GPS comenzó el 6 de enero de 1980; y el epoch de NTP es el 1 de enero de 1900. Al convertir entre sistemas, conocer el epoch de cada uno es esencial.

Segundos vs milisegundos

El timestamp Unix original está en segundos. La mayoría de los lenguajes y sistemas del lado del servidor (shell de Unix, time.time() en Python, time() en PHP, la mayoría de las bases de datos) usan segundos. En cambio, Date.now() y new Date().getTime() en JavaScript devuelven milisegundos. Esta diferencia es una fuente común de errores cuando frontends en JavaScript se comunican con API backend.

Un timestamp Unix en segundos suele tener 10 dígitos actualmente (alrededor de 1.700.000.000 en 2023). Un timestamp en milisegundos tiene 13 dígitos. La calculadora detecta el formato según la cantidad de dígitos y convierte en consecuencia.

El problema del año 2038

Los sistemas que almacenan timestamps Unix como enteros con signo de 32 bits solo pueden representar fechas hasta 2,147,483,647 segundos después del epoch — es decir, 03:14:07 UTC del 19 de enero de 2038. Después de ese momento, un entero con signo de 32 bits se desborda y pasa a un número negativo grande, representando una fecha en 1901.

Esto a veces se llama el problema “Y2K38” o el Unix Millennium Bug. Los sistemas modernos de 64 bits no se ven afectados, ya que un entero con signo de 64 bits puede representar timestamps durante aproximadamente 292 mil millones de años. Sin embargo, sistemas embebidos, bases de datos heredadas y software antiguo de 32 bits pueden seguir siendo vulnerables. Muchas industrias —incluidas telecomunicaciones, banca y control industrial— mantienen esfuerzos de migración para abordar este problema.

Cómo obtener el timestamp Unix actual

Lenguaje / entorno	Comando
JavaScript	Math.floor(Date.now() / 1000)
Python	import time; int(time.time())
PHP	time()
Bash	date +%s
SQL (PostgreSQL)	EXTRACT(EPOCH FROM NOW())::int
SQL (MySQL)	UNIX_TIMESTAMP()
Go	time.Now().Unix()
Rust	SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()

Usos prácticos

Desarrollo de API: Las API REST suelen usar timestamps Unix para campos como created_at, updated_at y expiración de tokens. Un timestamp no depende de zona horaria y es inequívoco — a diferencia de cadenas formateadas, que dependen de la configuración regional y el formato.

Expiración de tokens: Los JWT (JSON Web Tokens) usan timestamps Unix para las claims exp (expiración) e iat (emitido en). Un token expira cuando el timestamp actual supera el valor exp. Calcular expiraciones —“este token debe expirar en 24 horas”— requiere sumar 86.400 segundos al timestamp actual.

TTL de caché: La expiración de caché a menudo se define como un timestamp Unix o como una cantidad de segundos desde ahora. Depurar problemas de caché suele requerir convertir un timestamp de expiración almacenado a una fecha legible.

Análisis de logs: Los logs de servidor suelen incluir timestamps Unix. Convertirlos a fechas legibles es el primer paso para correlacionar entradas de log con eventos del mundo real.

Almacenamiento en bases de datos: Guardar timestamps como enteros en lugar de cadenas formateadas evita errores de conversión de zona horaria y simplifica ordenamiento, consultas por rango y operaciones aritméticas. Una consulta de “todos los registros de los últimos 7 días” se convierte en WHERE created_at > (NOW_UNIX - 604800).