Obtén el timestamp Unix actual en segundos y milisegundos. Convierte epoch a fecha/hora legible y viceversa. Soporta ISO 8601 y zonas horarias.
Un timestamp Unix (también llamado Unix time, POSIX time o epoch time) es una forma universal de representar cualquier instante en el tiempo como un único número entero: la cantidad de segundos transcurridos desde el 1 de enero de 1970 a las 00:00:00 UTC — conocido como el Unix Epoch.
Es el estándar más utilizado en desarrollo de software para almacenar, comparar y transmitir fechas y horas, porque elimina ambigüedades de zonas horarias, formatos locales y sistemas de calendario. Un timestamp es solo un número — simple, preciso y universalmente comprendido por cualquier lenguaje de programación o sistema operativo.
Ejemplo rápido: El timestamp 1700000000
equivale al 14 de noviembre de 2023 a las 22:13:20 UTC. En milisegundos,
el mismo instante es 1700000000000 — solo multiplica por 1.000.
Unix fue desarrollado entre 1969 y 1971 en los Bell Labs por Ken Thompson, Dennis Ritchie y otros ingenieros de AT&T. Necesitaban una forma simple de representar el tiempo en el sistema operativo. El 1 de enero de 1970 fue elegido porque era lo suficientemente reciente para evitar números negativos en fechas habituales. Con enteros de 32 bits, el sistema podía representar fechas desde 1901 hasta 2038. El estándar fue adoptado por POSIX en 1988 y hoy es soportado por todos los lenguajes de programación y sistemas operativos modernos.
| Unidad | Ejemplo (~2026) | Dígitos | Usado en |
|---|---|---|---|
| Segundos (s) | 1745000000 | 10 | Unix estándar, bases de datos, logs |
| Milisegundos (ms) | 1745000000000 | 13 | JavaScript Date.now(), APIs REST, eventos UI |
| Microsegundos (μs) | 1745000000000000 | 16 | Profiling de rendimiento, bases de datos HFT |
| Nanosegundos (ns) | 1745000000000000000 | 19 | Sistemas en tiempo real, redes de alta frecuencia |
Identificar la unidad por cantidad de dígitos: En 2026, un timestamp en segundos tiene 10 dígitos (~1.74 mil millones). En milisegundos tiene 13 dígitos. Contar los dígitos es el método más rápido para saber la unidad.
// Timestamp actual en milisegundos
const ms = Date.now(); // 1745000000000
// En segundos
const s = Math.floor(Date.now() / 1000); // 1745000000
// Timestamp → Date (¡recuerda multiplicar por 1000!)
const d = new Date(1700000000 * 1000);
console.log(d.toISOString()); // "2023-11-14T22:13:20.000Z"
console.log(d.toLocaleString('es-MX')); // "14/11/2023, 4:13:20 p. m."
// Date → Timestamp (segundos)
const ts = Math.floor(new Date('2024-01-01').getTime() / 1000);
// Diferencia entre fechas en días
const diffDias = (Date.now() - 1700000000000) / 1000 / 86400;
import time from datetime import datetime, timezone # Timestamp actual ts = int(time.time()) # segundos: 1745000000 ms = int(time.time() * 1000) # milisegundos: 1745000000000 # Timestamp → datetime (siempre usa UTC) dt = datetime.fromtimestamp(1700000000, tz=timezone.utc) print(dt.isoformat()) # 2023-11-14T22:13:20+00:00 # datetime → timestamp dt2 = datetime(2024, 1, 1, tzinfo=timezone.utc) ts2 = int(dt2.timestamp()) # 1704067200 # Diferencia entre fechas en días diff_dias = (time.time() - 1700000000) / 86400
-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP(); -- timestamp actual
SELECT FROM_UNIXTIME(1700000000); -- '2023-11-14 22:13:20'
SELECT UNIX_TIMESTAMP('2024-01-01 00:00:00'); -- 1704067200
-- PostgreSQL
SELECT EXTRACT(EPOCH FROM NOW())::BIGINT; -- timestamp actual
SELECT TO_TIMESTAMP(1700000000); -- '2023-11-14 22:13:20+00'
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'America/Mexico_City';
-- SQLite
SELECT strftime('%s', 'now'); -- timestamp actual
SELECT datetime(1700000000, 'unixepoch'); -- '2023-11-14 22:13:20'
# Timestamp actual date +%s # segundos date +%s%3N # milisegundos # Timestamp → fecha legible date -d @1700000000 # Linux (GNU date) date -r 1700000000 # macOS / BSD # Fecha → timestamp date -d "2024-01-01 00:00:00" +%s # Linux date -j -f "%Y-%m-%d" "2024-01-01" +%s # macOS
Los timestamps Unix siempre están en UTC (Tiempo Universal Coordinado) — no hay zona horaria incorporada en el número. Convertir a hora local es responsabilidad de la aplicación. Esta es la fuente más común de bugs relacionados con fechas en software.
| Zona horaria | Offset UTC | Timestamp 1700000000 = |
|---|---|---|
| UTC / GMT | +00:00 | 14 nov 2023 22:13:20 |
| Ciudad de México (CST) | −06:00 / −05:00 | 14 nov 2023 16:13:20 |
| Bogotá / Lima (COT) | −05:00 | 14 nov 2023 17:13:20 |
| Caracas (VET) | −04:00 | 14 nov 2023 18:13:20 |
| Buenos Aires (ART) | −03:00 | 14 nov 2023 19:13:20 |
| Madrid (CET/CEST) | +01:00 / +02:00 | 14 nov 2023 23:13:20 |
JavaScript fue creado en 1995 para navegadores, donde la precisión en milisegundos
es esencial para animaciones, eventos de mouse/teclado y temporizadores de UI.
Unix fue diseñado para sistemas operativos, donde la precisión en segundos es suficiente.
En la práctica: Date.now() devuelve ms, así que siempre divide entre 1000
para comparar con timestamps en segundos. Olvidar esta conversión es uno de los bugs
más comunes al integrar APIs de backend.
La aritmética de fechas con timestamps es solo una resta — la gran ventaja del formato:
ts2 - ts1(ts2 - ts1) / 60(ts2 - ts1) / 3600(ts2 - ts1) / 86400Constantes útiles: 1 min = 60s | 1 hora = 3.600s | 1 día = 86.400s | 1 semana = 604.800s | 1 año ≈ 31.536.000s (365 días).
Depende del caso de uso:
Recomendación: BIGINT en milisegundos para sistemas de backend, TIMESTAMPTZ para PostgreSQL.
ISO 8601 es el estándar internacional para representar fechas como texto:
2024-01-15T14:30:00Z. El sufijo Z indica UTC;
-06:00 indica Ciudad de México.
Los timestamps negativos representan fechas anteriores al 1 de enero de 1970.
Por ejemplo, -86400 es el 31 de diciembre de 1969 a las 00:00:00 UTC.
La mayoría de los lenguajes soportan timestamps negativos para fechas históricas.
Para trabajar con fechas muy antiguas, considera usar bibliotecas especializadas como
date-fns o Luxon (JS) o Arrow (Python).
Timestamp actual (2026): ~1.745.000.000 segundos | ~1.745.000.000.000 ms. Cuenta los dígitos: 10 = segundos, 13 = milisegundos.
Siempre UTC. Los timestamps no tienen zona horaria. Usa nombres
de zona (America/Mexico_City), nunca offsets fijos.
Constantes útiles: 1 min = 60s | 1 hora = 3.600s | 1 día = 86.400s | 1 semana = 604.800s | 1 año ≈ 31.536.000s.
⚠️ Algunas herramientas tienen su interfaz en portugués (Brasil) — pero funcionan perfectamente para cualquier desarrollador en el mundo.