Que es un timestamp Unix: como funcionan los segundos desde 1970 y el problema del 2038

Un timestamp Unix (tambien llamado Unix epoch, POSIX time o epoch time) es el numero de segundos transcurridos desde el 1 de enero de 1970 a las 00:00:00 UTC, conocido como el "Unix epoch".

Ejemplo: El timestamp 1742169600 corresponde al 17 de marzo de 2025 a las 00:00:00 UTC.

Por que 1970: Cuando Dennis Ritchie y Ken Thompson desarrollaron Unix en los laboratorios Bell a finales de los 1960s, necesitaban un punto de referencia. Eligieron el 1 de enero de 1970 como el "dia cero" porque era una fecha reciente, redonda y conveniente para el tamano de las variables de 32 bits de la epoca.

Ahora mismo: El timestamp Unix actual esta alrededor de 1,774,000,000 (1.77 mil millones de segundos desde 1970).

Convierte timestamps a fechas legibles con el conversor de timestamps de NexTools.

Timestamp → Fecha legible:

1742169600 → 17 de marzo de 2025, 00:00:00 UTC

Fecha → Timestamp:

17 de marzo de 2026, 00:00:00 UTC → 1773705600

En JavaScript:

// Timestamp a fecha
new Date(1742169600 * 1000).toISOString()
// "2025-03-17T00:00:00.000Z"

// Fecha a timestamp
Math.floor(new Date("2026-03-17").getTime() / 1000)
// 1773705600

Nota el × 1000: JavaScript usa milisegundos (13 digitos), no segundos (10 digitos). Este es el error mas comun al trabajar con timestamps en JS.

El conversor de NexTools maneja ambos formatos automaticamente.

El timestamp Unix se almacena como un entero con signo de 32 bits, que puede representar numeros hasta 2,147,483,647. Ese numero de segundos desde 1970 corresponde al 19 de enero de 2038 a las 03:14:07 UTC.

Despues de ese momento, el contador se desborda (overflow) y vuelve al numero mas negativo posible: -2,147,483,648, que corresponde al 13 de diciembre de 1901.

Quien esta afectado:

• Sistemas embebidos (cajeros automaticos, controladores industriales, IoT)
• Bases de datos que usan INT de 32 bits para timestamps
• Software legacy en C que usa time_t de 32 bits

Solucion: Migrar a timestamps de 64 bits. Linux kernel ya usa 64 bits desde 5.6 (2020). La mayoria de sistemas modernos (Node.js, Python, bases de datos recientes) ya usan 64 bits, soportando fechas hasta el ano 292,277,026,596.

Existen dos convenciones:

Error clasico: Pasar milisegundos donde se esperan segundos (o viceversa). Resultado: fechas en el ano 56,000 o en 1970. Si ves una fecha ridicula, verifica si estas multiplicando/dividiendo por 1000.

Calcula diferencias entre fechas con la calculadora de diferencia de fechas.

MySQL: UNIX_TIMESTAMP() retorna el timestamp actual. FROM_UNIXTIME(1773705600) convierte a fecha.

PostgreSQL: EXTRACT(EPOCH FROM NOW()). Soporta microsegundos y zonas horarias nativamente.

MongoDB: Usa ObjectId que incluye un timestamp de 4 bytes en los primeros caracteres. ObjectId.getTimestamp() lo extrae.

APIs REST: La convencion moderna es usar ISO 8601 ("2026-03-17T00:00:00Z") para endpoints publicos y timestamps numericos para uso interno. ISO 8601 es mas legible; timestamps son mas eficientes para ordenar y comparar.

Los timestamps Unix son SIEMPRE en UTC. No tienen zona horaria. Esto es una ventaja enorme:

Problema con fechas locales: "17 de marzo de 2026 a las 14:00" es ambiguo sin zona horaria. Son las 14:00 en Mexico (UTC-6)? Madrid (UTC+1)? Tokyo (UTC+9)? Tres momentos diferentes.

Timestamps resuelven esto: 1773757200 es un momento unico e inequivoco en el tiempo, independiente de donde estes. Luego cada cliente convierte a su zona local para mostrar al usuario.

Mejores practicas:

• Almacena siempre en UTC (timestamps o ISO 8601 con Z)
• Convierte a zona local solo para mostrar al usuario
• Nunca almacenes horas locales sin zona horaria

Si trabajas con zonas horarias, consulta el conversor de zonas horarias de NexTools.

JavaScript: Date.now() → milisegundos. Math.floor(Date.now()/1000) → segundos.

Python: import time; time.time() → segundos con decimales. int(time.time()) → entero.

PHP: time() → segundos.

Java: System.currentTimeMillis() → milisegundos.

Go: time.Now().Unix() → segundos.

Ruby: Time.now.to_i → segundos.

Bash: date +%s → segundos.

El conversor de NexTools acepta timestamps en ambos formatos (10 y 13 digitos) y los convierte a fecha legible al instante.

0 (1 ene 1970): El Unix epoch. El "dia cero" de la informatica moderna.

1000000000 (9 sep 2001): El "billionth second". Se celebro globalmente.

1234567890 (13 feb 2009): Secuencia memorable. Fiestas geek en todo el mundo.

2000000000 (18 may 2033): El proximo hito. Aun no llega.

2147483647 (19 ene 2038): El maximo de INT32. El Y2K38.

-1 (31 dic 1969): Un segundo antes del epoch. Usado como "fecha invalida" en muchos sistemas.

Dato curioso: Si ves una fecha del 1 de enero de 1970 en una app o dispositivo, casi seguro es un bug: algun sistema interpreto un 0 o null como timestamp.