Skip to content

Convertidor de Timestamp Unix y Epoch — Multi-Precisión

Convierte timestamps Unix a fechas al instante con nuestro convertidor epoch gratuito. Detecta automáticamente segundos, milisegundos y microsegundos. Reloj en vivo, bidireccional. Sin registro, 100% privado.

Sin rastreo Se ejecuta en el navegador Gratis
Todo el procesamiento ocurre en tu navegador. No se envían datos a ningún servidor.

Timestamp Unix Actual

0

Referencia Rápida

Ejemplos de Código

Revisado para cumplimiento POSIX y exactitud de precisión — Go Tools Engineering Team · Mar 22, 2026

¿Qué es un Timestamp Unix (Epoch Time)?

Un timestamp Unix (también llamado Epoch time o POSIX time) es el número de segundos transcurridos desde el 1 de enero de 1970 00:00:00 UTC, y sirve como referencia temporal universal para prácticamente todos los sistemas informáticos. Desde kernels de Linux y bases de datos SQL hasta motores JavaScript y sistemas operativos móviles, casi todas las plataformas modernas almacenan e intercambian el tiempo como un timestamp Unix.

Tal como lo define formalmente el IEEE Std 1003.1 (POSIX): "El epoch Unix (1 de enero de 1970 00:00:00 UTC) sirve como punto cero para el tiempo POSIX" — una convención tan universalmente adoptada que es ahora el estándar de facto para timestamps legibles por máquinas en todo el mundo.

El epoch Unix — 1 de enero de 1970 — no fue elegido de forma arbitraria. Unix fue desarrollado en Bell Labs a finales de los años 60, y 1970 fue un punto de partida conveniente y redondo lo suficientemente reciente como para representar todas las fechas relevantes con tamaños de entero manejables.

Los sistemas modernos a menudo necesitan mayor resolución que segundos enteros. Para ello, los timestamps se expresan comúnmente en milisegundos (milésimas de segundo, como devuelve `Date.now()` de JavaScript) o microsegundos (millonésimas de segundo, usados en bases de datos como PostgreSQL). Puedes identificar la precisión por el número de dígitos: 10 dígitos indica segundos, 13 dígitos indica milisegundos, y 16 dígitos indica microsegundos. Este convertidor detecta automáticamente la precisión de tu entrada.

Todas las conversiones ocurren completamente en tu navegador usando la API Date de JavaScript — ningún timestamp, fecha u otro dato se envía a ningún servidor.

// Get the current Unix timestamp in JavaScript
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // → 1741965432

// Milliseconds (native JavaScript)
const timestampMs = Date.now();
console.log(timestampMs); // → 1741965432000

// Convert timestamp back to a Date object
const date = new Date(timestampSeconds * 1000);
console.log(date.toISOString()); // → '2025-03-14T15:37:12.000Z'

// Python equivalent
// import time
// timestamp = int(time.time())  # → 1741965432

Características Principales

Detección Automática de Precisión

Detecta automáticamente si tu timestamp está en segundos (10 dígitos), milisegundos (13 dígitos) o microsegundos (16 dígitos) — sin necesidad de cambiar el modo manualmente.

Conversión Bidireccional

Convierte timestamps a fechas legibles, o elige cualquier fecha y hora para obtener al instante el timestamp Unix correspondiente en los tres formatos de precisión.

Reloj Epoch en Vivo

Observa el timestamp Unix actual actualizándose en tiempo real para tener siempre un punto de referencia preciso para tus conversiones y cálculos.

Salida en Múltiples Formatos

Cada conversión produce simultáneamente: hora UTC, tu zona horaria local, formato ISO 8601 y tiempo relativo (ej. "hace 3 días").

Procesamiento 100% en el Navegador

Todas las conversiones ocurren completamente en tu navegador usando la API Date de JavaScript. No se transmite ningún timestamp, fecha ni dato personal a ningún servidor.

Timestamp Unix vs Otros Formatos de Fecha

ISO 8601

2025-03-14T15:37:12Z

Tanto legible por humanos como ordenable lexicográficamente. El estándar para el intercambio de datos y APIs. Preferido sobre los timestamps Unix cuando la legibilidad humana importa.

RFC 2822

Fri, 14 Mar 2025 15:37:12 +0000

Legible por humanos pero no ordenable. Usado principalmente en cabeceras de correo electrónico (campo Date). Menos compacto que ISO 8601 y los timestamps Unix.

Fecha Legible

14 de marzo de 2025 15:37

El formato más legible para usuarios finales pero no ordenable ni adecuado para uso programático. Mejor reservado para capas de presentación de UI.

Ejemplos de Conversión

Timestamp Unix Estándar (segundos)

1741965432
2025-03-14T15:37:12Z

Un timestamp de 10 dígitos en segundos — el formato más común utilizado por sistemas Unix/Linux, APIs Unix, tokens JWT y registros de servidor. Este valor concreto corresponde al Día de Pi 2025 a las 15:37:12 UTC.

Timestamp Y2K — 1 de enero de 2000

946684800
2000-01-01T00:00:00Z

El timestamp Unix para el momento Y2K: exactamente 946.684.800 segundos después del epoch Unix. Es un valor de calibración útil — si tu convertidor muestra el 1 de enero de 2000 para esta entrada, está funcionando correctamente.

Timestamp Negativo (Antes del Epoch)

-86400
1969-12-31T00:00:00Z

Los timestamps Unix negativos representan fechas anteriores al 1 de enero de 1970. El valor -86400 es exactamente un día (86.400 segundos) antes del epoch, lo que corresponde al 31 de diciembre de 1969 a medianoche UTC.

Timestamp en Milisegundos (13 dígitos)

1741965432000
2025-03-14T15:37:12.000Z

Un timestamp de 13 dígitos en milisegundos — el formato nativo utilizado por Date.now() de JavaScript, System.currentTimeMillis() de Java y la mayoría de las APIs REST modernas. Es equivalente al primer ejemplo multiplicado por 1000.

Cómo Convertir un Timestamp Unix a Fecha

  1. 1

    Selecciona la Dirección de Conversión

    Elige "Timestamp → Fecha" para decodificar un timestamp Unix a una fecha legible, o "Fecha → Timestamp" para convertir una fecha y hora del calendario a un timestamp Unix.

  2. 2

    Introduce tu Valor

    Pega o escribe un timestamp Unix (ej. 1741965432 o 1741965432000) en el campo de entrada. La herramienta identifica automáticamente si está en segundos, milisegundos o microsegundos. Para Fecha → Timestamp, selecciona año, mes, día, hora, minuto y segundo con el selector de fecha.

  3. 3

    Copia el Resultado Convertido

    Ve instantáneamente el resultado en UTC, hora local, ISO 8601 y tiempo relativo. Haz clic en el botón Copiar junto a cualquier formato para copiarlo directamente al portapapeles.

Casos de Uso Comunes

Desarrollo y Depuración de APIs
Decodifica timestamps opacos en respuestas de API, payloads de tokens JWT (campos iat, exp, nbf), datos de eventos webhook y entradas de registro. Verifica instantáneamente si un token de autenticación ha expirado o cuándo ocurrió un evento.
Almacenamiento y Consultas de Timestamps en Bases de Datos
Convierte entre timestamps Unix y fechas legibles al escribir consultas de bases de datos, inspeccionar registros almacenados o validar que los filtros de rango de fechas están correctamente especificados en tus cláusulas WHERE.
Análisis y Correlación de Archivos de Log
Muchos registros de sistema y aplicación registran eventos como timestamps Unix. Convierte entradas de registro sospechosas a tiempos legibles para correlacionar eventos entre múltiples servicios o identificar el momento exacto en que ocurrió un error.
Verificación de Expiración de Tokens JWT
Los JSON Web Tokens codifican iat (emitido en), exp (expira en) y nbf (no antes de) como timestamps Unix en su payload. Pega estos valores directamente para verificar ventanas de validez del token.
Programación de Tareas Cron
Verifica que los programas de cron, tareas programadas y disparadores basados en tiempo se alineen con las ventanas de ejecución previstas convirtiendo los tiempos de ejecución propuestos a timestamps y viceversa.
Coordinación de Fechas entre Zonas Horarias
Los timestamps Unix son inherentemente neutrales con respecto a las zonas horarias. Usa este convertidor para establecer un punto de referencia compartido al coordinar fechas y plazos entre equipos en diferentes zonas horarias.

Referencia Técnica

Definición de Timestamp Unix
Un timestamp Unix es el conteo entero de segundos transcurridos desde el epoch Unix: 1 de enero de 1970, 00:00:00 UTC (Tiempo Universal Coordinado). El valor es el mismo independientemente de la zona horaria local del observador, lo que lo convierte en una representación ideal y neutral para almacenar y comparar tiempos.
Valor Máximo de Entero de 32 Bits con Signo
El valor máximo de un entero con signo de 32 bits es 2.147.483.647. Como timestamp Unix, esto corresponde al 19 de enero de 2038 a las 03:14:07 UTC. Los sistemas que almacenan timestamps en enteros de 32 bits con signo se desbordaran en ese momento — un problema conocido como el Problema del Año 2038.
JavaScript Usa Milisegundos
Date.now() y new Date().getTime() de JavaScript devuelven el número de milisegundos desde el epoch — no segundos. Esto produce números de 13 dígitos. Para convertir al timestamp Unix estándar en segundos, divide por 1000 y aplica floor: Math.floor(Date.now() / 1000).
Los Timestamps Negativos Representan Fechas Pre-Epoch
Los timestamps Unix pueden ser negativos para representar fechas anteriores al 1 de enero de 1970. Por ejemplo, -86400 representa el 31 de diciembre de 1969 a las 00:00:00 UTC. El rango de un timestamp de 64 bits con signo se extiende desde aproximadamente 292 mil millones de años antes del epoch hasta 292 mil millones de años después.
El Tiempo Unix No Tiene en Cuenta los Segundos Intercalares
El tiempo Unix asume exactamente 86.400 segundos por día (24 horas × 60 minutos × 60 segundos). En realidad, el IERS inserta ocasionalmente segundos intercalares para mantener UTC sincronizado con la rotación de la Tierra. Para la mayoría de las aplicaciones, esta discrepancia es irrelevante.

Buenas Prácticas para el Manejo de Timestamps

Almacena Siempre los Timestamps en UTC
Almacena los timestamps en UTC (o como timestamps Unix) y conviértelos a la hora local solo en la capa de presentación. Mezclar zonas horarias en tu base de datos es una fuente común de errores difíciles de reproducir y depurar, especialmente durante las transiciones de horario de verano.
Usa Precisión de Milisegundos para APIs Modernas
La mayoría de las APIs modernas, entornos JavaScript y bases de datos usan milisegundos (timestamps de 13 dígitos) en lugar de segundos (timestamps de 10 dígitos). Al integrar con sistemas externos, confirma la precisión esperada — pasar un timestamp en milisegundos donde se esperan segundos producirá fechas aproximadamente 11.000 años en el futuro.
Ten Cuidado con el Problema del Año 2038
Los sistemas que almacenan timestamps Unix en enteros de 32 bits con signo se desbordaran el 19 de enero de 2038 a las 03:14:07 UTC. Audita los sistemas heredados en busca de campos de timestamp de 32 bits y migra a enteros de 64 bits o cadenas ISO 8601.
Nunca Confíes en los Relojes del Lado del Cliente para Seguridad
Los relojes de los dispositivos del cliente pueden configurarse a cualquier valor, accidental o maliciosamente. Nunca uses un timestamp proporcionado por el cliente para lógica de seguridad como verificaciones de expiración de JWT, tiempos de espera de sesión o limitación de velocidad.
Usa ISO 8601 para Intercambio Legible por Humanos
Cuando necesitas un formato de timestamp que sea tanto procesable por máquinas como legible por humanos — por ejemplo en archivos de log, archivos de configuración o respuestas de API — ISO 8601 (ej. 2025-03-14T15:37:12Z) es la mejor opción. Es ordenable lexicográficamente, inequívoco y soportado por prácticamente todos los analizadores modernos.

Preguntas Frecuentes

¿Por qué el tiempo Unix empieza el 1 de enero de 1970?
La fecha del epoch Unix del 1 de enero de 1970 fue elegida por los desarrolladores de Unix en Bell Labs a finales de los años 60 como un punto de partida redondo y conveniente que era tanto reciente como computacionalmente práctico. En ese momento, los timestamps se almacenaban en enteros de 32 bits, por lo que el epoch debía estar lo suficientemente cerca del presente para que las fechas comunes cupieran en un número de tamaño razonable. 1970 era simplemente un año redondo y limpio posterior al inicio del desarrollo del sistema. No hay una significación técnica profunda en el 1 de enero de 1970 específicamente — fue un pragmatismo de ingeniería. Otros sistemas han elegido diferentes epochs: el Mac clásico usaba el 1 de enero de 1904; Windows NT usa el 1 de enero de 1601; el tiempo GPS comienza el 6 de enero de 1980. Lo que hizo que el epoch Unix se consolidara es que Unix se convirtió en el sistema operativo dominante en computación, y todos los principales lenguajes de programación, bases de datos y sistemas operativos adoptaron el tiempo Unix como estándar universal para representar timestamps legibles por máquinas.
¿Qué es el Problema del Año 2038?
El Problema del Año 2038 (también llamado Y2K38 o el Epochalypse) es un problema informático que afectará a los sistemas que almacenan timestamps Unix como enteros de 32 bits con signo. Un entero de 32 bits con signo puede contener valores de -2.147.483.648 a 2.147.483.647. Cuando se interpreta como un timestamp Unix, el valor máximo de 2.147.483.647 corresponde al 19 de enero de 2038 a las 03:14:07 UTC. Un segundo después, el contador se desbordará y regresará al valor más negativo representable, correspondiente al 13 de diciembre de 1901. La solución es sencilla: migrar a enteros de 64 bits con signo para el almacenamiento de timestamps. Un timestamp de 64 bits puede representar fechas aproximadamente 292 mil millones de años antes y después del epoch.
¿Cuál es la diferencia entre timestamps en segundos, milisegundos y microsegundos?
Los timestamps Unix vienen en tres precisiones comunes, distinguidas por el número de dígitos del valor: **Segundos (10 dígitos)**: El formato de timestamp Unix original y más común. `1741965432` representa un segundo específico. Usado por: llamadas al sistema Unix/Linux (`time()`), tokens JWT (campos `iat`, `exp`), cabeceras HTTP (`Last-Modified`). **Milisegundos (13 dígitos)**: Precisión de milésimas de segundo. `1741965432000` es el mismo momento que el anterior, multiplicado por 1.000. Usado por: `Date.now()` de JavaScript, `System.currentTimeMillis()` de Java, Node.js. **Microsegundos (16 dígitos)**: Precisión de millonésimas de segundo. `1741965432000000` es el mismo momento multiplicado por 1.000.000. Usado por: el tipo `TIMESTAMP` de PostgreSQL, sistemas de trading de alta frecuencia. El error más común es mezclar precisiones — por ejemplo, pasar un timestamp en milisegundos a una función que espera segundos. Esto produce fechas aproximadamente 11.574 años en el futuro.
¿Los timestamps Unix tienen en cuenta los segundos intercalares?
No — el tiempo Unix no tiene en cuenta los segundos intercalares, y esta es una de sus limitaciones conocidas para aplicaciones de cronometraje de precisión. El tiempo Unix asume un calendario perfectamente regular con exactamente 86.400 segundos por día. Para la gran mayoría de las aplicaciones de software — servicios web, APIs, bases de datos, lógica empresarial — la discrepancia acumulada de ~27 segundos de segundos intercalares durante más de 50 años es completamente irrelevante.
¿Los timestamps Unix pueden ser negativos?
Sí, los timestamps Unix pueden ser negativos, y los timestamps negativos son una forma legítima y bien definida de representar fechas anteriores al epoch Unix (1 de enero de 1970, 00:00:00 UTC). Cada segundo antes del epoch corresponde a un decremento de 1 desde cero. Por ejemplo, -1 representa el 31 de diciembre de 1969 a las 23:59:59 UTC; -86400 representa el 31 de diciembre de 1969 a las 00:00:00 UTC (exactamente un día antes del epoch). La mayoría de los lenguajes de programación y sistemas operativos modernos soportan timestamps negativos. Sin embargo, algunos sistemas más antiguos o drivers de bases de datos pueden no manejarlos correctamente.
¿Cómo obtengo el timestamp Unix actual en JavaScript, Python u otros lenguajes?
Obtener el timestamp Unix actual es sencillo en todos los lenguajes principales: **JavaScript / TypeScript:** ```javascript // Segundos (la mayoría de las APIs esperan esto) const seconds = Math.floor(Date.now() / 1000); // Milisegundos (nativo de JavaScript) const milliseconds = Date.now(); ``` **Python:** ```python import time seconds = int(time.time()) # 1741965432 ``` **Go:** ```go import "time" seconds := time.Now().Unix() // int64 milliseconds := time.Now().UnixMilli() // int64 ``` Lo más importante a recordar es que JavaScript trabaja nativamente en milisegundos, mientras que prácticamente todos los demás lenguajes usan segundos por defecto.
¿Cómo convierto el tiempo epoch a una fecha legible por humanos?
Hay tres formas rápidas de convertir el tiempo epoch (timestamps Unix) a una fecha legible: **1. Usa este convertidor online (más rápido)** Pega tu timestamp epoch en el campo de entrada de arriba. La herramienta detecta automáticamente si está en segundos, milisegundos o microsegundos y muestra el resultado instantáneamente. **2. Usa código** En JavaScript: `new Date(1741965432 * 1000).toISOString()` devuelve `'2025-03-14T15:37:12.000Z'`. En Python: `from datetime import datetime, UTC; datetime.fromtimestamp(1741965432, UTC)`. **3. Usa la línea de comandos** En macOS: `date -r 1741965432`. En Linux: `date -d @1741965432`.
¿Cuál es el timestamp Unix actual?
El timestamp Unix actual se muestra en el reloj en vivo en la parte superior de esta página, actualizándose cada segundo. El timestamp Unix es simplemente el número de segundos desde el 1 de enero de 1970 00:00:00 UTC, e incrementa exactamente en 1 cada segundo. A partir de 2026, el timestamp Unix actual está en el rango de los 1,77 mil millones (10 dígitos). Alcanzará los 2 mil millones alrededor de mayo de 2033, y el valor máximo para sistemas de 32 bits (2.147.483.647) se alcanzará el 19 de enero de 2038 a las 03:14:07 UTC — el llamado Problema del Año 2038.
Necesito depurar un timestamp en mi respuesta de API — ¿cómo lo convierto?
Copia el valor del timestamp de tu respuesta de API (típicamente será un número de 10 o 13 dígitos en un campo JSON como "created_at" o "timestamp"). Pégalo directamente en el campo de entrada de arriba — la herramienta detecta automáticamente si está en segundos o milisegundos y muestra inmediatamente la fecha UTC, la hora local y el formato ISO 8601. Si el timestamp está dentro de un token JWT, decodifica primero el payload JWT (que está codificado en Base64URL) para extraer los campos iat, exp o nbf, y luego pega esos valores aquí.
¿Qué ocurre con los timestamps Unix durante los cambios de horario de verano?
Los timestamps Unix no se ven afectados en absoluto por los cambios de horario de verano porque se basan en UTC, que no observa el horario de verano. Cuando los relojes "adelantan" o "atrasan" en una zona horaria local, el timestamp Unix continúa incrementándose exactamente en 1 por segundo sin ninguna interrupción o repetición. Esta es una de las ventajas clave de almacenar los tiempos como timestamps Unix en lugar de cadenas de fecha y hora locales.
¿Cómo obtengo el timestamp Unix actual en Python/JavaScript/Go?
En JavaScript, usa Math.floor(Date.now() / 1000) para segundos o Date.now() para milisegundos. En Python, usa import time; int(time.time()) para segundos, o int(time.time() * 1000) para milisegundos. En Go, usa time.Now().Unix() para segundos, time.Now().UnixMilli() para milisegundos, o time.Now().UnixMicro() para microsegundos. Recuerda que JavaScript trabaja nativamente en milisegundos mientras que Python y Go usan segundos por defecto — esta es la fuente más común de errores al integrar sistemas escritos en diferentes lenguajes. Documenta siempre qué precisión espera tu API en tu especificación OpenAPI/Swagger.
Tengo un timestamp en milisegundos — ¿cómo lo convierto a segundos?
Divide el timestamp en milisegundos entre 1000 y descarta la parte decimal. En JavaScript: Math.floor(ms / 1000). En Python: ms // 1000 (división entera). Por ejemplo, 1741965432000 (milisegundos) se convierte en 1741965432 (segundos). Puedes identificar los timestamps en milisegundos por su longitud de 13 dígitos frente a los 10 dígitos de los timestamps en segundos. Esta herramienta detecta automáticamente la precisión, por lo que puedes pegar cualquier formato directamente. La conversión inversa (segundos a milisegundos) es simplemente una multiplicación por 1000: 1741965432 * 1000 = 1741965432000. Ten cuidado de no pasar accidentalmente un valor en milisegundos a una función que espera segundos — el resultado sería una fecha aproximadamente 11.574 años en el futuro.

Herramientas relacionadas

Ver todas las herramientas →

Conversor de Bases — Binario, Hex, Decimal, Octal

Herramientas de Conversión

Convierte números entre binario, hexadecimal, decimal, octal y cualquier base personalizada (2-36) al instante. Gratis, privado, sin registro — todo el procesamiento ocurre en tu navegador.

Decodificador y Codificador Base64

Codificación y Formato

Decodifica y codifica Base64 online de forma gratuita. Conversión en tiempo real con soporte completo de UTF-8 y emojis. 100% privado — funciona en tu navegador. Sin registro.

Comprimir Imágenes Online — JPEG, PNG y WebP

Herramientas de Conversión

Reduce el tamaño de las imágenes hasta un 80% — comprime JPEG, PNG y WebP en tu navegador, sin subir archivos. Lotes de 20 imágenes, ajusta la calidad, compara antes y después. Gratis y privado.

Formateador y Validador JSON

Codificación y Formato

Formatea, valida y embellece JSON al instante en tu navegador. Herramienta gratuita con validación sintáctica, detección de errores, minificación y copia con un clic. 100% privado.

Convertidor de Longitud — Métrico e Imperial

Herramientas de Conversión

1 pulgada = 2,54 cm, 1 pie = 0,3048 m, 1 milla = 1,609 km. Convierte entre 16 unidades de longitud al instante — métrico, imperial, náutico y astronómico. Gratis, privado, funciona en tu navegador.

Generador de Hash MD5 Online y Verificador de Checksum

Herramientas de Seguridad

Genera hashes MD5, SHA-256, SHA-1 y SHA-512 gratis — 100% en tu navegador, sin registro. Hashea texto o archivos, verifica checksums y compara hashes con un clic. Tus datos permanecen privados.