Which epoch converter should I use?

Use Epoch to Date when you already have a Unix timestamp and need readable time. Use Date to Epoch when you have a calendar date, time, or datetime and need Unix seconds or milliseconds.

How do I convert a Unix timestamp to a readable date?

Paste your timestamp in the Epoch → Date tab above and click Convert. The tool auto-detects whether your timestamp is in seconds (10 digits) or milliseconds (13 digits) and shows the result in ISO 8601, UTC, and a friendly format for any timezone.

How do I convert a date or time to Unix timestamp?

Open the Date → Epoch tab, enter the date, time, and timezone, then copy the Unix timestamp in seconds or milliseconds.

What is the difference between Unix time in seconds and milliseconds?

A 10-digit timestamp (e.g. 1700000000) is in seconds. A 13-digit timestamp (e.g. 1700000000000) is in milliseconds. JavaScript's Date.now() returns milliseconds; most server-side languages (Python, PHP, Go) return seconds. Multiply by 1000 to convert seconds to milliseconds.

How do I convert milliseconds to seconds?

Divide the millisecond timestamp by 1000. In JavaScript, use Math.floor(milliseconds / 1000) when you need whole Unix seconds. To convert seconds back to milliseconds, multiply by 1000.

What is a 16-digit Unix timestamp?

A 16-digit Unix timestamp usually represents microseconds since the Unix epoch. Divide it by 1,000,000 to get seconds, or by 1000 to get milliseconds for JavaScript Date.

What is the difference between Unix time and UTC?

Unix time is a count of seconds elapsed since a fixed reference point (1970-01-01 00:00:00 UTC). UTC is the time standard that defines that reference point. A Unix timestamp always represents the same moment in UTC regardless of your local timezone.

Can a Unix timestamp be negative?

Yes. Timestamps before January 1, 1970 00:00:00 UTC are negative. For example, -86400 corresponds to December 31, 1969 00:00:00 UTC.

What is the Year 2038 problem?

Legacy systems that store Unix timestamps as 32-bit signed integers will overflow on January 19, 2038 at 03:14:07 UTC (the maximum value is 2,147,483,647). Modern 64-bit systems are unaffected and can represent dates billions of years in the future.

Conversor

Convertidor de timestamp Unix

Convierte entre timestamps Unix y fechas legibles. Un reloj epoch en vivo se actualiza cada segundo. Pega cualquier timestamp de 10 dígitos (segundos) o 13 dígitos (milisegundos) y conviértelo a cualquier zona horaria.

Timestamp Unix actual · en vivo

1783399215

Epoch → Fecha Fecha → Epoch

Timestamp Unix

Zona horaria

¿Qué es una marca de tiempo Unix?

Una marca de tiempo Unix es el número de segundos desde el 1 de enero de 1970 a las 00:00:00 UTC. También se llama tiempo epoch o tiempo POSIX. La conversión de tiempo Unix no incluye segundos intercalares. El valor es un único entero. Apunta a un solo instante. El entero no depende de la zona horaria ni de la configuración regional. Casi todos los lenguajes, bases de datos y sistemas operativos admiten marcas de tiempo epoch. Son el estándar universal para almacenar y enviar el tiempo entre sistemas.

The Open Group — Segundos desde la época (POSIX)

Segundos vs. milisegundos: detección automática del formato

La mayoría de las marcas de tiempo Unix están en segundos: un número de 10 dígitos que actualmente ronda los 1700 millones. El Date.now() de JavaScript y muchas API de navegador y web devuelven milisegundos en su lugar, produciendo un número de 13 dígitos. Este conversor detecta automáticamente la unidad a partir de la magnitud del valor introducido.

Número de 10 dígitos (p. ej. 1700000000) → segundos desde la época Unix
Número de 13 dígitos (p. ej. 1700000000000) → milisegundos desde la época Unix
Para convertir segundos a milisegundos: multiplica por 1000
Para convertir milisegundos a segundos: divide entre 1000 (usa Math.floor para obtener un entero)

¿Por qué el tiempo epoch empieza el 1 de enero de 1970?

La fecha fue elegida por los desarrolladores originales de Unix a principios de los años 70 como un punto de referencia conveniente anterior a la informática moderna. Dado que prácticamente todas las marcas de tiempo útiles son enteros positivos, la aritmética y las comparaciones son sencillas. Aunque la elección fue algo arbitraria, se volvió universal: todos los sistemas operativos, lenguajes de programación y protocolos modernos usan el mismo punto de referencia.

Conversión de tiempo Unix: cómo convertir epoch a una fecha legible

Usa la pestaña Epoch → Fecha de arriba: pega cualquier marca de tiempo Unix, elige tu zona horaria y haz clic en Convertir. La herramienta muestra el resultado en ISO 8601 (con desfase horario), cadena UTC, un formato largo amigable y un indicador de tiempo relativo. También puedes convertir en sentido contrario con la pestaña Fecha → Epoch.

ISO 8601 — formato estándar legible por máquina: 2023-11-15T06:13:20+00:00
Cadena UTC — legible con día de la semana: Wed, 15 Nov 2023 06:13:20 GMT
Amigable — estilo regional: Wednesday, November 15, 2023 at 6:13:20 AM UTC
Relativo — contextual: hace 1 año

Precisión de subsegundo, tiempo monótono y API modernas

El código moderno usa más que segundos y milisegundos. También maneja microsegundos y nanosegundos. El código distingue el tiempo de reloj de pared del tiempo monótono. La nueva API Temporal de JavaScript expone instantes con precisión de nanosegundos directamente. POSIX time_t sigue estando por debajo. En time_t de 32 bits con signo, sigue aplicando el límite de desbordamiento Y2038.

Segundos (10 dígitos) — el formato canónico POSIX time_t
Milisegundos (13 dígitos) — JavaScript Date y la mayoría de las API web
Microsegundos (16 dígitos) — registro de alta resolución, marcas de tiempo de Chrome/WebKit, precisión 6 de timestamp en Postgres
Nanosegundos (19 dígitos) — Temporal.Instant.epochNanoseconds (BigInt), Java Instant, Go time.UnixNano()
Tiempo de reloj de pared vs. tiempo monótono: usa Date.now() / time() para almacenar instantes; usa performance.now() / clock_gettime(CLOCK_MONOTONIC) para medir duraciones
Las abreviaturas de zona horaria (EST, PST, JST, IST, CST) son ambiguas: usa siempre un nombre IANA como America/New_York o Asia/Tokyo en el código
POSIX time_t en sistemas de 32 bits se desborda el 19/01/2038; time_t de 64 bits es el estándar moderno

La marca de tiempo Unix actual, en vivo

El reloj en la parte superior de esta página se actualiza cada segundo y muestra la época actual en segundos, la hora actual en milisegundos y la fecha. El mismo instante aparece de cinco formas: segundos epoch de 10 dígitos, milisegundos de 13 dígitos, ISO 8601, cadena UTC y un formato local amigable. El mismo conversor sirve también como calculadora de fecha y hora: úsalo como cambiador de hora y fecha entre zonas horarias o entre epoch y fechas humanas.

Reloj en vivo con segundos y fecha / tiempo epoch actual / tiempo Unix actual — se muestra en vivo en la parte superior de la página
Hora actual en ms (milisegundos) — el mismo instante que Date.now() en JavaScript
Marca de tiempo actual / marca de tiempo Unix actual — el valor canónico de 10 dígitos en segundos Unix
Semana actual — para hallar el inicio de esta semana como epoch, usa las marcas de tiempo de año/mes/semana de la página de Referencia
Calculadora de fecha y hora — para «fecha + N días = epoch?» usa la pestaña Fecha → Epoch con el valor de reloj de pared calculado
Cambiador de hora y fecha — elige una nueva zona horaria en el conversor y el mismo instante cambia su visualización
Unix a unix (entre sistemas): el entero es el mismo; la visualización cambia según la zona horaria
Timestamp unix time — el mismo número bajo tres nombres: marca de tiempo, tiempo Unix, tiempo epoch

Conversor de marca de tiempo epoch Unix — valores de referencia rápidos

Valores epoch redondos que aparecen con frecuencia al depurar o escribir pruebas. Cada valor va emparejado con la fecha y hora ISO 8601 correspondiente para que puedas verificarlo de un vistazo. Todos los instantes están en UTC.

0 → 1970-01-01T00:00:00Z (el origen de la época)
86400 → 1970-01-02T00:00:00Z (un día después de la época)
1000000000 → 2001-09-09T01:46:40Z (hito de diez dígitos)
1500000000 → 2017-07-14T02:40:00Z (referencia de mediados de 2017)
1700000000 → 2023-11-14T22:13:20Z (referencia reciente)
2000000000 → 2033-05-18T03:33:20Z (referencia futura)
2147483647 → 2038-01-19T03:14:07Z (máximo de un entero de 32 bits con signo — límite Y2038)
253402300799 → 9999-12-31T23:59:59Z (límite del año 9999 de PostgreSQL)

Convierte entre marcas de tiempo Unix, fechas y UTC

Este conversor gestiona todas las direcciones en un solo lugar. Pega cualquier valor de reloj de pared para convertir una fecha en una marca de tiempo Unix, o pega un entero epoch para obtener la fecha y hora UTC correspondiente para el análisis de registros. Un valor de 13 dígitos se detecta automáticamente como milisegundos y se convierte a segundos. El tiempo POSIX es solo otro nombre para el tiempo Unix: la misma operación en ambos casos. Funciona con segundos, milisegundos, microsegundos y cadenas ISO 8601.

Convertir tiempo a marca de tiempo Unix — pega cualquier fecha de reloj de pared y obtén segundos y milisegundos
Epoch a UTC — pega un entero epoch y ve la fecha y hora UTC correspondiente
Millis a marca de tiempo — los valores de 13 dígitos se detectan automáticamente como milisegundos y se convierten a segundos
Conversor de tiempo POSIX — el tiempo POSIX es solo otro nombre para el tiempo Unix; misma herramienta, misma operación
Conversión de tiempo Unix en cualquier dirección — fecha ↔ epoch, seg ↔ ms, local ↔ UTC

Sistemas informáticos, hora local y el límite del 19 de enero de 2038

El tiempo Unix es el estándar de medición del tiempo que usan los sistemas informáticos de todo el mundo, desde servidores y bases de datos hasta dispositivos embebidos y sistemas operativos. Internamente, estos sistemas almacenan el tiempo como un entero Unix y luego lo representan como hora local para quien lo ve. La convención tiene un límite famoso: el 19 de enero de 2038 a las 03:14:07 UTC, las marcas de tiempo Unix de 32 bits con signo se desbordan. Los sistemas modernos de 64 bits no se ven afectados. Las implementaciones heredadas de 32 bits aún requieren atención antes de esa fecha.

Sistemas informáticos que cuentan el tiempo como enteros Unix: Linux, macOS, Windows, BSD, iOS, Android y todos los principales motores de bases de datos
Hora local vs. UTC: la marca de tiempo en sí está en UTC; la hora local es solo una de muchas representaciones posibles
19 de enero de 2038 a las 03:14:07 UTC — cuando las marcas de tiempo Unix de 32 bits con signo alcanzan 2 147 483 647 y se desbordan
Los sistemas informáticos de 64 bits extienden el rango seguro hasta cerca del año 292 000 millones, mucho más allá de cualquier preocupación práctica
La hora local depende del desfase horario y de las reglas de horario de verano: aplícala solo en la visualización, nunca al almacenar

Cómo calcula este conversor

Cada conversión de esta página se ejecuta por completo en tu navegador usando la definición POSIX estándar del tiempo Unix: segundos desde el 1970-01-01 00:00:00 UTC, sin segundos intercalares. Las marcas de tiempo que introduces nunca se envían a un servidor; el cálculo ocurre localmente en JavaScript. Las horas se calculan en UTC y se muestran en la zona horaria que elijas solo al visualizarlas.