Timestamp Unix: convertir un epoch y evitar errores de zona horaria

Convierte un epoch Unix en una fecha legible y al revés, distingue segundos de milisegundos y evita las trampas de zona horaria, JWT y cambio de hora.

19.10.2026

20 min de lectura

Compartir este artículo:

Timestamp UnixEpochZona horariaJWTTutorial

Un epoch cuenta segundos y no lleva zona horaria

Un número como 1710000000 o 1710000000000 aparece en una línea de log, en la respuesta de una API, en un JWT o en una columna de base de datos. Cuenta el tiempo transcurrido desde el 1 de enero de 1970 a las 00:00:00 UTC, contado como segundos o como milisegundos. No lleva zona horaria. El conversor de timestamp Unix convierte un epoch en fecha y una fecha en epoch. Los campos vacíos siguen un reloj en vivo. Escribe un epoch, una fecha ISO o una fecha y hora locales, y los otros dos campos se actualizan. Una tabla muestra el epoch como segundos y como milisegundos, y además ISO 8601, RFC 2822, un datetime SQL, un texto en tu idioma y un tiempo relativo. Usa UTC o la zona horaria de tu navegador. La conversión se hace en la pestaña y no se envía nada. Esta guía lee un epoch cifra a cifra y luego muestra qué cambia una zona horaria y qué deja intacto. Trata los errores que más cuestan: segundos leídos como milisegundos, un JWT que nunca caduca, una fecha escrita sin zona y un cambio de hora. También da los límites de 2038 y de otros epochs, y las mismas conversiones en JavaScript, Python, una shell y Java. Las herramientas relacionadas están en el hub de utilidades para desarrolladores.

Un reloj en vivo arriba de la página, con el epoch actual como segundos y como milisegundos, un botón Pausar y un botón Copiar ISO (UTC)

Tres campos enlazados: Epoch Unix, ISO / texto de fecha y Fecha/hora local. Cambia uno y los otros dos lo siguen

Unidad automática: hasta 10 cifras se leen como segundos, de 11 a 15 cifras como milisegundos, y una insignia indica la elección

Una tabla de formatos con un botón Copiar en cada fila: epoch (segundos), epoch (milisegundos), ISO 8601, RFC 2822, datetime SQL, cadena local y tiempo relativo

Vista en UTC o Local. Local es la zona horaria de tu navegador: la herramienta no tiene una lista de zonas

Se aceptan epochs negativos y fracciones de segundo, y los valores de más de 15 cifras se rechazan en lugar de recortarse

Sin subida de archivos: el cálculo se queda en el navegador

Para qué sirve el conversor y dónde termina

Buenos usos

El conversor responde a dos preguntas: qué instante nombra este número y qué número nombra este instante.

Leer un epoch de una línea de log, un campo de API o una fila de base de datos, y mirar la insignia para saber si la herramienta lo tomó por segundos o por milisegundos

Escribir una fecha como epoch para una consulta o un caso de prueba, y copiar la fila que necesites

Pasar de UTC a Local para ver cuánto desplaza una zona el mismo instante y en qué día cae

Comprobar los claims <code>exp</code>, <code>iat</code> y <code>nbf</code> de un token pegando cada número y eligiendo Segundos como unidad

Pegar la fila ISO 8601 en un ticket o en una revisión de código, para que quien lo lea vea la fecha con su desfase

Usar Pausar en el reloj en vivo para mantener quieto un epoch mientras lo copias

Lo que corresponde a otra herramienta

El conversor lee un valor cada vez. El resto de la cadena se comprueba en otro sitio.

Decodificar un token para leer sus claims: el <a href="/es/jwt-decode" class="text-primary hover:underline">decodificador JWT</a> muestra <code>exp</code> como el número en bruto del payload, y la <a href="/es/blog/codificar-decodificar-jwt-en-linea" class="text-primary hover:underline">guía de JWT</a> explica los claims

Saber cuándo se dispara una tarea: el <a href="/es/cron-parser" class="text-primary hover:underline">analizador cron</a> calcula las próximas ejecuciones, y la <a href="/es/blog/analizar-expresion-cron-proxima-ejecucion" class="text-primary hover:underline">guía de cron</a> trata zonas horarias y cambios de hora en ese contexto

Pasar un log de servidor web a una tabla: la herramienta <a href="/es/access-log-to-table" class="text-primary hover:underline">access log a tabla</a> conserva la fecha tal como está escrita, por ejemplo <code>09/Mar/2024:16:00:00 +0000</code>, y el conversor la rechaza. Reescríbela antes como <code>2024-03-09T16:00:00+00:00</code>

Elegir una zona con nombre, como Tokio: el conversor ofrece solo UTC y la zona de tu navegador. Usa <code>Intl.DateTimeFormat</code> o la biblioteca de zonas de tu lenguaje (mira el código más abajo)

Leer microsegundos, nanosegundos o un FILETIME de Windows: tienen 16 cifras o más y se rechazan. Divide tú mismo entre 1000 o entre 10 000 000 y resta el desfase de epoch cuando lo haya

Convertir un archivo entero: la herramienta lee un valor cada vez

Sumar un mes o un año a una fecha: usa una biblioteca de fechas, porque en un reloj local un día no siempre dura 86 400 segundos

Leer un valor sin equivocarse

Distinguir segundos y milisegundos por las cifras

En modo Auto, la herramienta cuenta las cifras de la parte entera, sin el signo. Puedes pegar los ejemplos de abajo en el campo Epoch Unix.

<code>1710000000</code> tiene 10 cifras y se lee como segundos: sábado 9 de marzo de 2024 a las 16:00:00 UTC. La insignia dice «Inferido: segundos»

<code>1710000000000</code> tiene 13 cifras y se lee como milisegundos. Da el mismo instante, y la insignia dice «Inferido: milisegundos»

Del 9 de septiembre de 2001 (<code>1000000000</code>) al 20 de noviembre de 2286 (<code>9999999999</code>), un epoch de segundos tiene 10 cifras. En el mismo periodo, uno de milisegundos tiene 13

<code>10000000000</code> tiene 11 cifras y se lee como milisegundos: 26 de abril de 1970 a las 17:46:40 UTC. Leído como segundos, un valor de ese tamaño sería el año 2286

Una fecha de enero de 1970 casi siempre significa que se leyeron segundos como milisegundos. <code>1710000000</code> leído como milisegundos es el 20 de enero de 1970 a las 19:00:00 UTC. Pon la unidad en Milisegundos para verlo

Una fecha del año <code>56157</code> significa lo contrario. <code>1710000000000</code> leído como segundos da <code>+056157-09-28T16:00:00.000Z</code>. Elige Segundos como unidad para verlo

A partir de 16 cifras, la herramienta responde «Este valor parece más preciso que milisegundos» y no muestra ninguna fecha

Fracciones, signos y lo que el campo rechaza

El campo Epoch Unix acepta cifras, un signo menos opcional y un punto decimal.

<code>1710000000.5</code> es 16:00:00.500 UTC. La función <code>time.time()</code> de Python devuelve este tipo de valor: segundos con fracción

Las cifras más allá del milisegundo se cortan, no se redondean: <code>1710000000.123456</code> da 16:00:00.123

<code>0</code> es el 1 de enero de 1970 a las 00:00:00 UTC, <code>-1</code> el 31 de diciembre de 1969 a las 23:59:59 y <code>-86400</code> el 31 de diciembre de 1969 a las 00:00:00. POSIX deja sin definir los valores negativos, pero JavaScript y Python los manejan

Una coma decimal (<code>1710000000,5</code>), un exponente (<code>1e9</code>) y un valor hexadecimal se rechazan con «No se ha podido interpretar esta entrada»

El mismo instante en cuatro zonas

Toma 1710000000. El epoch no cambia, solo cambia su lectura. Pon Zona horaria en Local para ver la línea de tu propia zona.

UTC: sábado 9 de marzo de 2024 a las 16:00:00

París: 17:00:00, UTC+1 (hora de invierno hasta el 31 de marzo de 2024)

Nueva York: 11:00:00, UTC-5. Estados Unidos pasó al horario de verano al día siguiente, el 10 de marzo de 2024, y Nueva York está en UTC-4 desde entonces

Tokio: domingo 10 de marzo de 2024 a las 01:00:00, UTC+9. La zona también mueve el día, algo que importa cuando cortas logs por días

El campo Fecha/hora local sigue siempre el reloj de pared de tu navegador, aunque la tabla esté en UTC. Una ayuda bajo el campo lo recuerda

El texto de una fecha, con zona o sin ella

Escribe una fecha en el campo ISO / texto de fecha para obtener su epoch. El resultado depende de lo que hayas escrito tras la hora. Los valores de abajo se comprobaron en Node 26, que usa el mismo motor de JavaScript que Chrome. Otros navegadores pueden leer de otra forma las formas que no son ISO.

<code>2024-03-09T16:00:00Z</code> da <code>1710000000</code> en cualquier zona del navegador, porque la <code>Z</code> indica UTC

<code>2024-03-09T16:00:00+01:00</code> da <code>1709996400</code>, es decir, las 15:00 UTC

<code>2024-03-09T16:00:00</code> no tiene desfase y se lee en la zona del navegador: <code>1710000000</code> en UTC, <code>1709996400</code> en París, <code>1710018000</code> en Nueva York y <code>1709967600</code> en Tokio

<code>2024-03-09</code>, una fecha sola, se lee como medianoche UTC: <code>1709942400</code> en cualquier zona. Añadir una hora sin desfase cambia la regla

<code>2024-03-09 16:00:00</code> con un espacio y <code>March 9, 2024</code> no son formas ISO. El motor probado aquí las lee en hora local, y el estándar deja la regla a cada motor

<code>09/03/2024</code> se lee con el mes primero, como el 3 de septiembre de 2024. Un formato con el día primero hay que reescribirlo en ISO

<code>Sat, 09 Mar 2024 16:00:00 GMT</code>, la forma RFC 2822 de las cabeceras HTTP, se entiende y da <code>1710000000</code>

Cinco errores que solo se ven en producción

Pasar segundos donde se esperan milisegundos, o al revés

JavaScript cuenta en milisegundos, y la mayoría de los demás lenguajes y protocolos cuentan segundos. new Date(1710000000) da el 20 de enero de 1970 a las 19:00:00 UTC. En Python 3.14, datetime.fromtimestamp(1710000000000, tz=timezone.utc) se detiene con year must be in 1..9999, not 56157. Java separa los dos casos en Instant.ofEpochSecond y en Instant.ofEpochMilli, y nada te avisa si eliges el equivocado.

Pasar el resultado de <code>Date.now()</code> a una función que espera segundos, o el de <code>time()</code> a <code>new Date()</code>

Dividir entre 1000 dos veces, o ninguna, a lo largo de una cadena de tres servicios

Guardar milisegundos en una columna de entero de 32 bits, que no pasa de 2 147 483 647

Leer nanosegundos con <code>JSON.parse</code>: 1710000000123456789 vuelve como 1710000000123456800, porque los números de JavaScript solo son exactos hasta 9 007 199 254 740 991. Lee el campo como cadena o como BigInt

Comparar un campo de segundos con un campo de milisegundos y obtener un resultado siempre verdadero o siempre falso

Escribe la unidad en el nombre (<code>created_at_ms</code>, <code>expires_in_s</code>) y en la descripción de la API, y prueba con un valor que sepas leer, como el epoch de hoy al mediodía.

Un JWT que caduca dentro de más de 50 000 años

La RFC 7519 define exp, nbf y iat como segundos desde el epoch, sin contar los segundos intercalares. Un token firmado con exp puesto a Date.now() + 3600000 lleva milisegundos. Con la biblioteca jose en su versión 6, un token así firmado el 9 de marzo de 2024 seguía aceptándose cuando la fecha de comprobación era 2034. Su exp de 1710003600000, leído como segundos, vale +056157-11-09T08:00:00.000Z. El conversor oculta el error si dejas la unidad en Auto, porque lee 13 cifras como milisegundos y muestra una fecha normal.

Calcular <code>exp</code> desde un reloj en milisegundos, como en <code>Date.now() + 3600 * 1000</code>

Pegar <code>exp</code> en el conversor con la unidad en Auto y concluir que la fecha es correcta

Fiarse del verificador: compara números y no puede saber qué unidad tenías en mente

Mezclar <code>iat</code> como segundos y <code>exp</code> como milisegundos en el mismo payload, de modo que el token parece vivir para siempre

Decodifica el token y pega <code>exp</code> eligiendo Segundos como unidad. Una fecha de 2026 es correcta. Una fecha posterior al año 3000 es un error.

Leer una fecha sin zona

El texto de una fecha sin desfase no nombra ningún instante hasta que se elige una zona. En Python, datetime(2024, 3, 9, 16, 0, 0).timestamp() en una máquina con zona París da 1709996400, no 1710000000. JavaScript lee 2024-03-09 como medianoche UTC, pero 2024-03-09T00:00:00 como medianoche en hora local: dos formas de escribir el mismo día difieren en el desfase de la máquina.

Guardar una hora de reloj local como si fuera UTC y mostrarla luego a usuarios de otra zona

Obtener un epoch distinto para la misma cadena en un portátil en París y en un servidor en UTC

Cortar los logs por días en UTC cuando quienes los leen trabajan en otra zona: <code>1710000000</code> ya es el día 10 en Tokio

Escribir una fecha sin zona en un caso de prueba, de modo que una prueba pasa en un país y falla en otro

Escribe el desfase o una <code>Z</code> en cada fecha que intercambies. Guarda el epoch o la fecha en UTC y aplica una zona solo al mostrarla.

Fiarse de una hora local a través de un cambio de hora

Europa vuelve al horario de invierno el domingo 25 de octubre de 2026, a las 01:00 UTC. En París, las 03:00 vuelven a ser las 02:00, así que las 02:30 ocurren dos veces: a las 00:30 UTC (1792888200) y a las 01:30 UTC (1792891800). Con el navegador en zona París, el campo Fecha/hora local toma la primera. El 29 de marzo de 2026 la hora de las 02:00 a las 03:00 no existe, y el campo responde que no puede interpretar las 02:30. El epoch elimina la duda, porque nombra un solo instante.

Sumar 86 400 segundos para obtener «la misma hora mañana». Desde las 09:00 en París del 24 de octubre de 2026 se obtienen las 08:00 del día 25, porque ese día dura 25 horas

Guardar una hora local sin su desfase y encontrar dos epochs posibles tras la vuelta al horario de invierno

Programar una tarea a las 02:30 en hora local y verla ejecutarse dos veces, o ninguna (la guía de cron trata este caso)

Creer que dos horas locales separadas por 24 horas siempre distan 86 400 segundos

Haz los cálculos con epochs o fechas en UTC y convierte a hora local solo para mostrar. Usa una biblioteca de fechas cuando necesites «la misma hora mañana».

Olvidar los límites del formato

Un epoch es fácil de guardar y fácil de desbordar. Los límites de abajo vienen del ancho del tipo que lo contiene.

Guardar un epoch en un entero de 32 bits con signo: el último segundo es <code>2147483647</code>, el 19 de enero de 2038 a las 03:14:07 UTC. Un segundo después, el contador salta a una fecha de 1901

Usar una columna MySQL <code>TIMESTAMP</code> para una fecha posterior a 2038: la documentación da '2038-01-19 03:14:07' UTC como límite superior

Dar por segura una columna de 32 bits sin signo: termina en <code>4294967295</code>, y <code>4294967296</code> es el 7 de febrero de 2106 a las 06:28:16 UTC

Contar con los segundos intercalares: el tiempo Unix cuenta cada día como exactamente 86 400 segundos, así que la diferencia entre dos epochs puede ser un segundo menor que el tiempo realmente transcurrido

Usa un entero de 64 bits o un tipo de fecha nativo, y prueba los valores límite <code>2147483647</code> y <code>4294967296</code> en el conversor.

Unidades, límites y otros epochs de un vistazo

La unidad de cada sistema

Lee la documentación del sistema que produjo el número antes de fiarte de sus cifras.

JavaScript: <code>Date.now()</code> y <code>getTime()</code> devuelven milisegundos

Python: <code>time.time()</code> devuelve segundos como número decimal, y <code>time.time_ns()</code> devuelve nanosegundos

Java: <code>System.currentTimeMillis()</code> devuelve milisegundos, mientras que <code>Instant.getEpochSecond()</code> devuelve segundos

PHP: <code>time()</code> devuelve segundos, y <code>microtime(true)</code> devuelve segundos como número decimal

Shell: <code>date +%s</code> imprime segundos. La versión de GNU de <code>date</code> también imprime milisegundos con <code>date +%s%3N</code>

JWT: <code>iat</code>, <code>nbf</code> y <code>exp</code> son siempre segundos, y la RFC 7519 admite una fracción

El conversor de FastMinify: segundos hasta 10 cifras, milisegundos de 11 a 15 cifras y rechazo a partir de 16 cifras

Números que conviene conocer

Estos valores se reconocen rápido una vez vistos, y puedes pegar cada uno en el conversor.

<code>0</code>: 1 de enero de 1970 a las 00:00:00 UTC, el origen

<code>1000000000</code>: 9 de septiembre de 2001 a las 01:46:40 UTC, el primer epoch con 10 cifras

<code>2147483647</code>: 19 de enero de 2038 a las 03:14:07 UTC, el final de un entero de 32 bits con signo

<code>4294967296</code>: 7 de febrero de 2106 a las 06:28:16 UTC, uno más allá del final de un entero de 32 bits sin signo

<code>9999999999</code>: 20 de noviembre de 2286 a las 17:46:39 UTC, el último epoch con 10 cifras

<code>8640000000000</code> segundos: 13 de septiembre de 275760, la última fecha que cabe en un <code>Date</code> de JavaScript. Con Segundos como unidad, la herramienta la acepta y rechaza un segundo más

Epochs que no empiezan en 1970

Algunos sistemas cuentan desde otro origen o en otra unidad. Si una fecha sale desplazada por décadas, busca uno de estos casos.

FILETIME de Windows: pasos de 100 nanosegundos desde el 1 de enero de 1601. El desfase con Unix es de 11 644 473 600 segundos. Para <code>1710000000</code>, el FILETIME vale 133544736000000000, con 18 cifras, y el conversor lo rechaza

Tiempo absoluto de Apple (Core Data, Cocoa): segundos desde el 1 de enero de 2001, un desfase de 978 307 200 segundos. <code>1710000000</code> pasa a ser 731692800

Tiempo GPS: segundos desde el 6 de enero de 1980, un desfase de 315 964 800 segundos. Ignora los segundos intercalares, así que la diferencia con UTC crece con el tiempo

Ticks de .NET: pasos de 100 nanosegundos desde el 1 de enero del año 1. El epoch Unix está a 62 135 596 800 segundos de ese origen

Fechas de serie de Excel y Google Sheets: días desde el 30 de diciembre de 1899 en el sistema por defecto. El 1 de enero de 1970 es el día 25 569, y <code>1710000000</code> equivale a 45360,67 (la fracción es la hora)

El conversor de timestamp Unix, paso a paso

Leer un epoch

El conversor de timestamp Unix se actualiza poco después de la última tecla. No hay botón Convertir.

Mirar el reloj en vivo

El bloque «Hora Unix actual» muestra el epoch como Segundos y como Milisegundos, cada uno con un botón Copiar. Pausar detiene el reloj y Reanudar lo vuelve a poner en marcha. Copiar ISO (UTC) toma la fecha del momento.

Escribir o pegar el epoch

Usa el campo Epoch Unix. Una insignia como «Inferido: segundos» indica cómo se leyeron las cifras. Puedes forzar Segundos o Milisegundos con la opción Unidad.

Leer la tabla Formatos

Lista el epoch como segundos y como milisegundos, ISO 8601, RFC 2822 y un datetime SQL. Añade una cadena local en el idioma de la página y un tiempo relativo. RFC 2822 usa los nombres de días y meses en inglés. La fila relativa cuenta un mes como 30 días y un año como 365, así que es una referencia aproximada.

Copiar la fila que necesitas

Cada fila tiene su propio botón Copiar. Un mensaje breve confirma lo que se copió.

Partir de una fecha

Los tres campos se mantienen sincronizados. El que modificas manda sobre los demás.

ISO / texto de fecha

Escribe 2024-03-09T16:00:00Z para obtener el epoch. El campo Epoch Unix se rellena con segundos, o con milisegundos si la unidad está en Milisegundos.

Fecha/hora local

Usa este campo para introducir una fecha en tu reloj de pared. Nunca es UTC, aunque la tabla muestre UTC, y una ayuda bajo el campo lo dice.

Comprobar la zona que querías

Si el texto ISO no lleva Z ni desfase, el navegador aplica su propia zona. Añade el desfase cuando quieras que el resultado sea el mismo en todas las máquinas.

Ajustar las opciones

Dos ajustes cambian cómo la página lee y muestra un valor.

Unidad

Auto lee hasta 10 cifras como segundos y de 11 a 15 cifras como milisegundos. Segundos y Milisegundos fuerzan la lectura. Usa Segundos para los claims de un JWT.

Zona horaria

UTC es el valor por defecto. Local usa la zona de tu navegador y cambia las filas ISO, RFC 2822, SQL y cadena local. Las filas de epoch nunca cambian.

Cargar ejemplo y Borrar todo

Cargar ejemplo introduce 1710000000. Borrar todo vacía los campos y devuelve el reloj en vivo.

Entender un rechazo

Cuando un valor no se puede leer, la herramienta dice por qué y no muestra ninguna fecha.

No se ha podido interpretar esta entrada

El texto no es un número ni una fecha que el navegador entienda. Reescribe la fecha en ISO 8601, por ejemplo 2024-03-09T16:00:00+00:00.

Este valor parece más preciso que milisegundos

El número tiene 16 cifras o más, como los microsegundos, los nanosegundos o un FILETIME. Quita primero las cifras que sobran.

Las mismas conversiones en JavaScript, Python, una shell y Java

JavaScript

JavaScript trabaja en milisegundos. Multiplica o divide entre 1000 en la frontera con los sistemas que usan segundos, y da una zona a Intl.DateTimeFormat cuando necesites una con nombre.

Ejemplo básico

const epochSeconds = 1710000000

// Seconds -> Date: multiply by 1000
new Date(epochSeconds * 1000).toISOString()   // 2024-03-09T16:00:00.000Z
new Date(epochSeconds).toISOString()          // 1970-01-20T19:00:00.000Z  (seconds read as milliseconds)

// Date -> seconds: divide by 1000 and round down
Math.floor(Date.parse('2024-03-09T16:00:00Z') / 1000)   // 1710000000

// A named zone for display. The epoch does not change.
const fmt = new Intl.DateTimeFormat('es-ES', {
  timeZone: 'Asia/Tokyo',
  dateStyle: 'medium',
  timeStyle: 'long',
})
fmt.format(epochSeconds * 1000)   // 10 mar 2024, 1:00:00 GMT+9

// Date alone is UTC, date with a time and no offset is local
Date.parse('2024-03-09')            // 1709942400000 in every zone
Date.parse('2024-03-09T16:00:00')   // depends on the zone of the machine

Python

Pasa una zona horaria en cada llamada. Un datetime ingenuo no tiene ninguna, y timestamp() usa entonces la zona de la máquina.

Ejemplo básico

import time
from datetime import datetime, timezone
from zoneinfo import ZoneInfo

ts = 1710000000

datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
# '2024-03-09T16:00:00+00:00'
datetime.fromtimestamp(ts, tz=ZoneInfo('America/New_York')).isoformat()
# '2024-03-09T11:00:00-05:00'

# Milliseconds: divide first, or Python raises ValueError (year out of range)
datetime.fromtimestamp(1710000000000 / 1000, tz=timezone.utc)

# Date -> epoch, with the zone written down
int(datetime(2024, 3, 9, 16, 0, 0, tzinfo=timezone.utc).timestamp())   # 1710000000

# Without tzinfo the result depends on the machine (TZ=Europe/Paris gives 1709996400)
int(datetime(2024, 3, 9, 16, 0, 0).timestamp())

time.time()   # a float in seconds, for example 1792398878.41

Una shell

Las versiones de GNU y de BSD de date, la primera en Linux y la segunda en macOS, no tienen las mismas opciones.

Ejemplo básico

# Current epoch in seconds (GNU and macOS)
date +%s

# Epoch -> date, GNU date (Linux)
date -u -d @1710000000 +%Y-%m-%dT%H:%M:%SZ    # 2024-03-09T16:00:00Z
TZ=Europe/Paris date -d @1710000000 +%FT%T%z   # 2024-03-09T17:00:00+0100

# Epoch -> date, BSD date (macOS)
date -u -r 1710000000 +%Y-%m-%dT%H:%M:%SZ     # 2024-03-09T16:00:00Z

# Milliseconds, GNU date only
date +%s%3N

Java

La API java.time guarda la unidad en el nombre del método, y por eso una confusión se ve en una revisión de código.

Ejemplo básico

import java.time.*;

Instant.ofEpochSecond(1710000000L);        // 2024-03-09T16:00:00Z
Instant.ofEpochMilli(1710000000000L);      // 2024-03-09T16:00:00Z

Instant.ofEpochSecond(1710000000L)
    .atZone(ZoneId.of("Europe/Paris"));    // 2024-03-09T17:00+01:00[Europe/Paris]

Instant.parse("2024-03-09T16:00:00Z").getEpochSecond();   // 1710000000

Conclusión

Un epoch nombra un solo instante, y casi todos los errores vienen de cómo se lee. Cuenta las cifras para distinguir segundos de milisegundos, escribe el desfase en cada fecha y deja la zona horaria para mostrar. El conversor de timestamp Unix muestra el mismo instante en los formatos que necesitas, en UTC o en tu propia zona. Lee un valor cada vez, no ofrece una lista de zonas y rechaza los valores de 16 cifras o más. Para un token, lee sus claims con el decodificador JWT y pega exp eligiendo Segundos como unidad. Para un log, reescribe antes la fecha en ISO 8601. El hub de utilidades para desarrolladores lista las herramientas relacionadas.

Convertir un timestamp Unix en tu navegador

Timestamp Unix Decodificador JWT Access log a tabla Hub de utilidades

Cuenta las cifras: 10 para segundos, 13 para milisegundos, y desconfía de cualquier fecha de 1970 o posterior al año 3000

Escribe el desfase o una Z en cada fecha que guardes o envíes

Haz los cálculos con epochs o fechas en UTC y convierte a hora local solo para mostrar

Elige Segundos como unidad cuando compruebes los claims de un JWT

Usa un entero de 64 bits y prueba los valores 2147483647 y 4294967296

Compartir este artículo

Compartir este artículo:

Un epoch cuenta segundos y no lleva zona horaria

Para qué sirve el conversor y dónde termina

Leer un valor sin equivocarse

Cinco errores que solo se ven en producción

Unidades, límites y otros epochs de un vistazo

El conversor de timestamp Unix, paso a paso

Mirar el reloj en vivo

Escribir o pegar el epoch

Leer la tabla Formatos

Copiar la fila que necesitas

ISO / texto de fecha

Fecha/hora local

Comprobar la zona que querías

Unidad

Zona horaria

Cargar ejemplo y Borrar todo

No se ha podido interpretar esta entrada

Este valor parece más preciso que milisegundos

Las mismas conversiones en JavaScript, Python, una shell y Java

Ejemplo básico

Ejemplo básico

Ejemplo básico

Ejemplo básico

Conclusión

Artículos relacionados