Epoch Converter: epoch a fecha y fecha a epoch

Pegue cualquier timestamp o fecha y véalo en palabras, en su zona horaria y en UTC, con todo lo demás que podría ser el número.

s · ms · µs · ns · FILETIME · .NET · Excel · NTP · GPS · funciona en su navegador

Ejemplo · 817876800

sábado

2 de diciembre de 1995

04:00:00 UTC

UTC
sáb, 2 dic 1995 · 04:00:00
sáb, 2 dic 1995 · 04:00:00UTC · UTC+00:00
Relativo
hace 31 años
Escrito como
ISO 8601 · UTC
1995-12-02T04:00:00Z
ISO 8601 · UTC
1995-12-02T04:00:00Z
RFC 5322 · correoel formato que definió el RFC 2822
Sat, 02 Dec 1995 04:00:00 +0000
Fecha HTTPRFC 9110
Sat, 02 Dec 1995 04:00:00 GMT
SQL DATETIMEUTC
1995-12-02 04:00:00
Segundos
817876800
Milisegundos
817876800000
Microsegundos
817876800000000
Nanosegundos
817876800000000000

Un número · todos los epochs

7 lecturas caen en una fecha real

Lectura: Segundos Unix, por su longitud (9 dígitos). Con la lectura Segundos GPS sería el 6 de diciembre de 2005: también una fecha real, así que queda a un clic.

LecturaCae en
1900–2100: una fecha realHoy2038: el límite de 32 bitsNo cae en ninguna fecha realElija una lectura para usarla
Ahora

Milisegundos
Microsegundos
Nanosegundos
ISO 8601

El reloj de su navegador cuenta milisegundos enteros: los ceros que siguen son relleno, no precisión.

Fecha y hora → timestamp
Zona horaria

UTC · UTC+00:00 en esta fecha

1793813880
Milisegundos
1793813880000
ISO 8601
2026-11-04T17:38:00Z
Inicio y fin en UTC
InicioFin
Día17937504001793836799
Mes17934912001796083199
Año17672256001798761599

Todo ocurre en esta pestaña: nada de lo que pega se envía a ninguna parte.

Cómo usar este conversor Unix de epoch a fecha

Pegue en el campo el timestamp que tenga, en la unidad que sea, y la fecha aparece en su propia zona horaria y en UTC. También puede escribir una fecha, el encabezado Date de un correo o la palabra ahora para obtener su tiempo epoch.

La página lee un número a la vez en segundos, milisegundos, microsegundos y nanosegundos, elige la lectura que cae en una fecha real, dice por qué y deja las demás lecturas a un clic. Debajo de la respuesta, los mismos dígitos se leen como un timestamp de Windows, .NET, Mac, Excel, NTP y GPS, y cada formato se puede copiar.

Epoch Converter leyendo 133756272000000000 como Windows FILETIME: 9 de noviembre de 2024, cada epoch en una línea de tiempoEpoch Converter leyendo 133756272000000000 como Windows FILETIME: 9 de noviembre de 2024, cada epoch en una línea de tiempoPegue lo que seaUn número en cualquier unidad, una fecha ISO, el encabezado Date de un correo, un datetime SQL o la palabra ahora. La etiqueta indica cómo se leyó.Los dígitos, contadosLa regla bajo el número agrupa sus dígitos de tres en tres, así que 18 dígitos se leen como seis grupos: la primera pista de lo que es.Primero, la respuestaEl día de la semana y la fecha en palabras, luego la hora en UTC y en su propia zona horaria, y cada formato para copiar.Qué lectura, y por quéLa página dice en palabras qué lectura eligió y por qué, y nombra la otra lectura que también cae en una fecha real.Todos los demás epochsLos mismos dígitos leídos en cada unidad y cada epoch, cada uno como una barra desde su propio inicio. Elija una fila para usar esa lectura.
La herramienta leyendo un Windows FILETIME. Elija un número para ver qué hace cada parte.

¿Qué es el tiempo epoch (tiempo Unix) y por qué empieza en 1970?

El tiempo epoch, o tiempo Unix, es el número de segundos transcurridos desde 1970-01-01 00:00:00 UTC, el momento que POSIX llama el Epoch. El timestamp 0 es ese momento, y la fecha epoch 817876800 es 1995-12-02 04:00 UTC.

Ninguna fuente primaria registra por qué se eligió 1970. El primer manual de Unix, en noviembre de 1971, contaba sexagésimos de segundo desde el 1 de enero de 1971 y advertía que su reloj se agotaría en unos dos años y medio; para la séptima edición, en 1979, la cuenta era de segundos desde el 1 de enero de 1970, una fecha redonda cercana a cuando se estaba escribiendo Unix. El propio UTC no comenzó hasta 1972, así que los timestamps anteriores son UTC por convención.

Unix, primera edición, 1971sexagésimos de segundo desde el 1 de enero de 1971, en 32 bits

se llenó el 8 de abril de 1973 · 2,27 años

Unix, séptima edición, 1979segundos desde el 1 de enero de 1970, en un número de 32 bits con signo

1901-12-13 → 2038-01-1968 años en cada sentido

valores negativos: antes de 1970

El usuario de mentalidad--cronológica notará que 2**32 sexagésimos de segundo son solo unos 2,5 años.

UNIX Programmer's Manual, primera edición, time (II), 3 de noviembre de 1971

Todos los epochs que lee esta página, en una sola línea

  1. .NET0001-01-01 · ticks de 100 ns
  2. Windows FILETIME1601-01-01 · ticks de 100 ns
  3. Excel1899-12-30 · días
  4. NTP1900-01-01 · segundos
  5. Mac HFS+1904-01-01 · segundos
  6. Excel 19041904-01-01 · días
  7. Unix1970-01-01 · segundos
  8. GPS1980-01-06 · segundos
Ambas barras se calculan a partir del tamaño del contador: 2³² sexagésimos de segundo llenan 2,27 años, un poco menos que la propia estimación del manual. Cada uno de los demás epochs que lee esta página empieza en otro punto de la misma línea, dibujada sobre el eje de tiempo del propio conversor. Fuente: time (II), 1971, time (2), 1979

¿Mi timestamp está en segundos, milisegundos, microsegundos o nanosegundos?

Cuente los dígitos: un timestamp actual tiene 10 dígitos en segundos, 13 en milisegundos, 16 en microsegundos y 19 en nanosegundos. JavaScript y Java usan milisegundos; las herramientas Unix y la mayoría de las API, segundos.

La cantidad de dígitos es una pista fuerte, no una prueba. Los timestamps de NTP, GPS y Mac también tienen diez dígitos hoy, y un Windows FILETIME y una cuenta de ticks de .NET tienen dieciocho, por eso esta página lee todas las escalas a la vez y muestra la lectura que eligió junto a las demás. Además, un FILETIME es más grande de lo que JavaScript puede guardar con exactitud, así que la página conserva los dígitos tal como los pegó.

10 dígitos · 4 escalas · los dígitos por sí solos no dicen cuál

Segundos Unix1792972800
Segundos NTP4001961600
Segundos GPS1477008018
Mac HFS+3875817600
Milisegundos Unix1792972800000
Microsegundos Unix1792972800000000

18 dígitos · 2 escalas · solo el primer dígito las distingue

Windows FILETIME134374464000000000
Ticks de .NET639285696000000000
Nanosegundos Unix1792972800000000000

Los segundos de 10 dígitos van de 2001-09-09T01:46:40Z a 2286-11-20T17:46:39Z. Es un intervalo de 285 años, no una unidad.

Cada valor es el mismo instante, 26 de octubre de 2026, 00:00 UTC, en su propia escala. La longitud distingue las unidades Unix; no puede distinguir los epochs. Fuente: ECMA-262 §21.4.1, [MS-DTYP] 2.3.3, DateTime.Ticks

¿Cómo convierto un timestamp Unix a una fecha en mi zona horaria?

Un timestamp Unix no tiene zona horaria: nombra un mismo instante en todas partes. La fecha depende de dónde se lea, así que la página muestra su propia zona y UTC lado a lado, y cualquier otra zona que elija.

El selector de zonas usa la base de datos de zonas horarias de IANA, la misma que usa su sistema operativo, así que los cambios de horario de verano se aplican para la fecha en sí, no para hoy. En sentido contrario, una fecha escrita sin desfase se lee como UTC, y la página ofrece leerla en su propia zona.

Un instante1793057400= 2026-10-26T23:30:00Z

  • Los Ángeles16:30lun, 26 octUTC−07:00
  • Nueva York19:30lun, 26 octUTC−04:00
  • UTC23:30lun, 26 octUTC+00:00
  • Berlín00:30mar, 27 octUTC+01:00
  • Calcuta05:00mar, 27 octUTC+05:30
  • Tokio08:30mar, 27 octUTC+09:00
  • Lord Howe10:30mar, 27 octUTC+11:00

Berlín, 29 de marzo de 202623 horas · los relojes saltaron de 02:00 a 03:00

Berlín, 25 de octubre de 202625 horas · los relojes retrocedieron de 03:00 a 02:00

hora estándar de Europa central · UTC+01:00hora de verano de Europa central · UTC+02:00la hora que ocurrió dos vecesla hora que nunca ocurrió

Un timestamp, 7 relojes locales: donde la fecha local no es la de UTC, está marcada. En los dos días de cambio de hora de Berlín en 2026, una hora del reloj no correspondió a ningún instante y otra correspondió a dos. Fuente: ECMA-262 §21.4.1.19, IANA tz

¿Qué le pasa al tiempo Unix en 2038?

Un tiempo Unix guardado como entero de 32 bits con signo se agota en 2147483647, que es 2038-01-19 03:14:07 UTC; un segundo después salta a una fecha de diciembre de 1901. Los sistemas que cuentan en 64 bits, como ahora exige POSIX, no se ven afectados.

En 2026 el riesgo está en el almacenamiento, no en los relojes: una columna TIMESTAMP de MySQL todavía termina en 2038-01-19 03:14:07 UTC, igual que cualquier formato de archivo o dispositivo embebido que haya conservado un campo de 32 bits. NTP tiene su propio desbordamiento, anterior: sus segundos de 32 bits vuelven a cero en 2036. La página marca cualquier timestamp cercano al límite de 2038 o más allá.

2.147.483.647el mayor número de 32 bits con signo

01111111 11111111 11111111 11111111

mar, 19 ene 203803:14:07 UTC

+ 1 segundo

-2.147.483.648los mismos 32 bits, leídos como número con signo

10000000 00000000 00000000 00000000

vie, 13 dic 190120:45:52 UTC

Último segundo, UTC

time_t de 32 bits con signo2038-01-19 03:14:07
Segundos de 32 bits sin signo2106-02-07 06:28:15
Columna TIMESTAMP de MySQL2038-01-19 03:14:07
NTP, era 02036-02-07 06:28:15
Fechas de Mac HFS+2040-02-06 06:28:15

hoy2038-01-19

Cada final se calcula a partir del tamaño del campo: el último segundo entero que puede guardar. Un time_t de 64 bits, que exige POSIX.1-2024, llega a unos 292 mil millones de años antes y después de 1970. Fuente: POSIX.1-2024 A.4.19, MySQL 8.4, RFC 5905 §6, TN1150

¿Puede un timestamp Unix ser negativo?

Sí: un timestamp negativo es una fecha anterior a 1970. -1 es 1969-12-31 23:59:59 UTC, y -86400 es 1969-12-31 00:00:00 UTC.

El propio POSIX deja sin definir los valores negativos, pero GNU y la mayoría de los sistemas los tratan como fechas anteriores a 1970 mediante una extensión documentada, al igual que JavaScript, Python y PostgreSQL. MySQL es la excepción: su columna TIMESTAMP empieza en 1970, y FROM_UNIXTIME(-1) devuelve NULL. Las fechas de nacimiento y los registros históricos son timestamps negativos comunes, así que la página los lee como fechas en lugar de tratarlos como un error.

SegundosCuánto hacia atrás (escala log.)Fecha, UTC

0jue, 1 ene 197000:00:00 UTC
-1mié, 31 dic 196923:59:59 UTC
-86.400mié, 31 dic 196900:00:00 UTC
-31.536.000mié, 1 ene 196900:00:00 UTC
-1.000.000.000dom, 24 abr 193822:13:20 UTC
-2.147.483.648vie, 13 dic 190120:45:52 UTC
  • POSIXSi el año es <1970 o el valor es negativo, la relación no está definida.
  • GNU date@-1 es 1969-12-31 23:59:59 UTC: valores negativos, como extensión de POSIX
  • JavaScriptcualquier fecha hasta unos 273.790 años antes o después de 1970
  • MySQL TIMESTAMPempieza en 1970-01-01 00:00:01 UTC: no puede guardar un valor negativo
Cada valor se lee como segundos Unix. Las barras están en escala logarítmica, para que los valores pequeños sigan visibles. La última fila es el número más pequeño que guarda un campo de 32 bits con signo: el otro extremo del problema de 2038. Fuente: POSIX.1-2024 §4.19, GNU Coreutils, ECMA-262 §21.4.1, MySQL 8.4

Windows, .NET, Mac, Excel, NTP y GPS: los otros epochs

Muchos sistemas cuentan desde su propio cero: Windows desde 1601, .NET desde el año 1, Mac y HFS+ desde 1904, Excel desde 1900, NTP desde 1900 y GPS desde el 6 de enero de 1980. Un número que no tiene sentido como timestamp Unix suele ser uno de estos.

El FILETIME 133756272000000000, por ejemplo, cuenta intervalos de 100 nanosegundos desde 1601 y es 2024-11-09 12:00:00 UTC. Excel cuenta días y trata 1900 como año bisiesto a propósito, así que sus números de serie por debajo de 61 tienen un día de diferencia, y la página los marca. El tiempo GPS omite los segundos intercalares y va 18 segundos por delante de UTC desde 2017.

EpochCuentaDesdeEl 26 oct 2026DígitosZona horariaDónde aparece
Segundos Unixsegundos1970-01-01179297280010UTC (POSIX)date +%s, time.time() en Python
Milisegundos Unixmilisegundos1970-01-01179297280000013UTCDate.now() en JavaScript, Java
Nanosegundos Unixnanosegundos1970-01-01179297280000000000019UTCUnixNano() en Go
Windows FILETIMEticks de 100 ns1601-01-0113437446400000000018UTC (hora local en FAT)NTFS, lastLogon de Active Directory, Win32
Ticks de .NETticks de 100 ns0001-01-0163928569600000000018UTC o local, según KindDateTime.Ticks
N.º de serie de Exceldías1899-12-30463215ninguna: fecha y hora sin zonaExcel, Google Sheets, LibreOffice
Excel 1904días1904-01-01448595ninguna: fecha y hora sin zonaversiones antiguas de Excel para Mac
Mac HFS+segundos1904-01-01387581760010GMT (HFS clásico: local)fechas de archivos HFS+
Segundos NTPsegundos1900-01-01400196160010UTCpaquetes NTP
Segundos GPSsegundos1980-01-06147700801810sin segundos intercalares: UTC + 18sreceptores GPS, archivos RINEX
Cada valor es el mismo instante, 26 de octubre de 2026, 00:00 UTC, en su propia escala, calculado por el motor con el que funciona esta página. Google Sheets y LibreOffice también cuentan los días desde 1899-12-30, así que desde el 1 de marzo de 1900 sus números de serie coinciden con los de Excel. Fuente: [MS-DTYP] 2.3.3, DateTime.Ticks, Excel, Google Sheets, LibreOffice, TN1150, RFC 5905, RINEX 3.05

¿El tiempo Unix cuenta los segundos intercalares?

No. El tiempo Unix da a cada día exactamente 86.400 segundos, así que un segundo intercalar no tiene número propio, y POSIX lo dice: el tiempo POSIX desglosado no es necesariamente UTC, a pesar de su apariencia.

Desde 1972 se han añadido 27 segundos intercalares a UTC; el tiempo Unix no tiene número para el segundo extra, así que un timestamp representa dos segundos. El último fue el 2016-12-31, y en 2022 la Conferencia General de Pesas y Medidas decidió que para 2035 se elevará el límite que los hace necesarios, lo que en la práctica les pone fin. El tiempo GPS, que nunca los tuvo, muestra la diferencia: va 18 segundos por delante.

Los últimos segundos del 31 de diciembre de 1998

UTC23:59:5823:59:5923:59:6000:00:0000:00:01
Tiempo Unix915148798915148799915148800915148800915148801
Tiempo GPS599184010599184011599184012599184013599184014

El tiempo Unix da 915148800 dos veces; el tiempo GPS, que no tiene segundos intercalares, sigue contando.

27 segundos intercalaresninguno después del 31 de diciembre de 2016 · ninguno anunciado antes del 28 de junio de 2027

antes de que empezara el tiempo GPSdesde que empezó el tiempo GPS: cada uno lo adelantó un segundo más

El tiempo universal coordinado (UTC) incluye segundos intercalares. Sin embargo, en el tiempo POSIX (segundos desde el Epoch), los segundos intercalares se ignoran (no se aplican) para ofrecer un método fácil y compatible de calcular diferencias de tiempo. Por lo tanto, el tiempo POSIX desglosado no es necesariamente UTC, a pesar de su apariencia.

POSIX.1-2024, Rationale A.4.19
Justo después de este segundo intercalar, el tiempo GPS iba 13 segundos por delante de UTC. Fuente: POSIX.1-2024 A.4.19, leap-seconds.list, RINEX 3.05

Timestamps Unix en Python, JavaScript, Java, C#, Go, SQL y la shell

Cada lenguaje convierte en ambos sentidos en una o dos líneas. Las trampas son la unidad (JavaScript y Java cuentan milisegundos) y la zona horaria (una base de datos puede leer el valor en la zona de su sesión).

Cada ejemplo de abajo convierte 817876800 en una fecha y una fecha de nuevo en segundos, y cada uno se ejecutó para comprobar su salida. En la shell, macOS y los BSD usan date -r 817876800, mientras que GNU/Linux usa date -d @817876800: no son intercambiables.

from datetime import datetime, timezone

t = datetime.fromtimestamp(817876800, tz=timezone.utc)
print(t.isoformat())  # 1995-12-02T04:00:00+00:00

back = datetime(1995, 12, 2, 4, 0, tzinfo=timezone.utc)
print(int(back.timestamp()))  # 817876800

Ejecutado con Python 3.14.4 el 26 de octubre de 2026: imprime lo que muestran los comentarios.

Cada pestaña es un programa o una sesión completa que se ejecuta tal como se pega; en la pestaña Shell, ejecute la mitad que corresponde a su sistema. Fuente: docs.python.org, ECMA-262, Instant, DateTimeOffset, pkg.go.dev/time, PostgreSQL, MySQL, date(1), GNU Coreutils

Tiempo epoch: preguntas y respuestas

¿Qué es el tiempo epoch?

El tiempo epoch, también llamado tiempo Unix o timestamp Unix, es el número de segundos transcurridos desde 1970-01-01 00:00:00 UTC, sin contar los segundos intercalares. Las computadoras guardan las fechas así porque un solo número es fácil de comparar, ordenar y enviar. El timestamp 1000000000 fue 2001-09-09 01:46:40 UTC, y el campo de arriba convierte cualquier valor en una fecha.

¿Cómo convertir epoch a fecha?

Pegue el número en el campo de arriba. La página lo lee en segundos, milisegundos, microsegundos y nanosegundos, elige la lectura que cae en una fecha real y muestra esa fecha en su zona horaria y en UTC. A mano, multiplique los segundos por 1.000 y páselos a una función de fecha, como new Date(817876800 * 1000) en JavaScript.

¿Cuál es el tiempo epoch actual?

El reloj de esta página muestra en vivo el tiempo Unix actual, en segundos, milisegundos, microsegundos y nanosegundos, y cada valor se puede copiar. Viene del reloj de su propio dispositivo, así que solo es tan preciso como ese reloj; una computadora que se sincroniza por internet suele desviarse menos de un segundo. En la línea de comandos, date +%s lo muestra en segundos.

¿Un timestamp Unix está en segundos o en milisegundos?

Los timestamps Unix clásicos están en segundos, pero JavaScript, Java y muchas API web usan milisegundos, y algunas bases de datos y registros usan microsegundos o nanosegundos. Un timestamp actual tiene 10 dígitos en segundos y 13 en milisegundos. Si una fecha sale en 1970 o a miles de años en el futuro, la unidad es incorrecta; esta página prueba cada unidad y muestra cuál tiene sentido.

¿Por qué el tiempo Unix empieza en 1970?

Ninguna fuente primaria registra el motivo. El primer manual de Unix, de 1971, contaba sexagésimos de segundo desde el 1 de enero de 1971 y preveía agotarse en pocos años. Cuando la cuenta pasó a segundos enteros, el 1 de enero de 1970 se convirtió en el inicio: una fecha redonda cercana a cuando se estaba escribiendo Unix, desde la cual una cuenta de segundos de 32 bits llega hasta 2038.

¿El tiempo Unix es lo mismo que UTC?

Casi, pero no exactamente. El tiempo Unix sigue el calendario y el reloj de UTC, pero da a cada día exactamente 86.400 segundos e ignora los segundos intercalares, así que un segundo intercalar no tiene timestamp propio. El propio POSIX dice que un tiempo Unix desglosado no es necesariamente UTC. En las fechas y horas que lee la gente, la diferencia nunca se nota; en intervalos precisos que cruzan un segundo intercalar, sí.

¿Qué es el problema del año 2038?

Un tiempo Unix guardado como número de 32 bits con signo solo puede llegar a 2147483647, que es 2038-01-19 03:14:07 UTC. Un segundo después se desborda y se lee como diciembre de 1901. Los sistemas operativos modernos usan tiempo de 64 bits y están a salvo, pero quedan campos de 32 bits en algunas bases de datos, formatos de archivo y dispositivos embebidos: la columna TIMESTAMP de MySQL, por ejemplo, todavía termina en ese segundo.

¿Puedo convertir una fecha anterior a 1970?

Sí. Las fechas anteriores a 1970 son timestamps negativos: -1 es 1969-12-31 23:59:59 UTC, y una fecha de 1950 ronda los -631 millones. Pegue un número negativo y la página muestra su fecha; escriba una fecha más antigua y le da el valor negativo. El POSIX estricto deja sin definir los valores negativos y TIMESTAMP de MySQL no puede guardarlos, pero la mayoría de los lenguajes y bases de datos los leen como fechas anteriores a 1970.

¿Cómo convertir un Windows FILETIME a fecha?

Un FILETIME cuenta intervalos de 100 nanosegundos desde 1601-01-01 UTC, así que hoy tiene 18 dígitos. Péguelo en el campo y la página lo lee como FILETIME junto a las unidades Unix: 133756272000000000 es 2024-11-09 12:00:00 UTC. A mano, reste 116444736000000000 y divida entre 10.000.000 para obtener segundos Unix.

¿Cómo convertir un número de serie de Excel a timestamp?

Un número de serie de Excel cuenta días, con fracciones para la hora: en el sistema 1900 predeterminado, 45658 es 2025-01-01. Pegue el número de serie y la página lo lee como fecha de Excel en los sistemas 1900 y 1904. Excel trata 1900 como año bisiesto a propósito, así que los números de serie por debajo de 61 tienen un día de diferencia, y la página los marca en lugar de adivinar.

¿El conversor maneja zonas horarias y horario de verano?

Sí. La página muestra cada fecha en su propia zona horaria y en UTC, y puede elegir cualquier zona IANA, como America/New_York o Asia/Kolkata. El horario de verano se aplica para la fecha que se convierte, no para hoy, así que un timestamp de verano muestra la hora de verano incluso en invierno. Una fecha escrita sin desfase se lee como UTC, y un clic la lee en su propia zona.

¿Se envía mi timestamp a algún lugar?

No. La conversión se hace en su navegador, así que lo que pega nunca sale de su dispositivo y ningún servidor lo ve. Un enlace creado con “Copiar enlace” lleva el timestamp en su dirección para que la página que abre ya muestre la fecha; no se guarda ni se envía nada más.

¿Le falta algo?Sugiera una función o una herramienta nueva