Timestamp Unix: distingue segundos, milisegundos y nanosegundos

Contenido
Un número como 1784298258, el que aparece en la respuesta de una API o en un log del servidor, puede decirte exactamente a qué momento se refiere con solo contar sus dígitos. Un timestamp Unix tiene un rango de dígitos definido según esté en segundos o en milisegundos.
Si no conoces esta regla y metes el número tal cual en el constructor Date de JavaScript, te saldrá una fecha absurda: algo cercano a los años 70 o un año de decenas de miles. Este artículo repasa las reglas de cálculo para distinguir segundos, milisegundos, microsegundos y nanosegundos solo contando dígitos.
Resumen ① De 1 a 11 dígitos son segundos, de 12 a 14 dígitos son milisegundos, de 15 a 17 dígitos son microsegundos y 18 dígitos o más son nanosegundos. ② Si confundes un valor en segundos de 10 dígitos con milisegundos y lo pasas tal cual a Date, obtienes algo cercano a 1970; y si confundes un valor en milisegundos de 13 dígitos con segundos y lo multiplicas por 1000, obtienes un año de decenas de miles. ③ Un mismo timestamp se ve distinto en UTC y en hora local según el desfase horario, y un valor negativo indica un momento anterior a 1970.
Por qué en la práctica se confunde el número de dígitos
En los logs del servidor y en las respuestas de API es muy habitual que el timestamp aparezca como un número sin ninguna indicación de unidad. Cada sistema puede devolverlo en segundos o en milisegundos, así que, aunque el nombre del campo sea el mismo (created_at, timestamp, etc.), el número real de dígitos del valor puede ser distinto.
El problema es que el constructor Date de JavaScript siempre trabaja en milisegundos. new Date(x) interpreta x como los milisegundos transcurridos desde las 0:00 del 1 de enero de 1970 (UTC).
Si le pasas un número en segundos, lo está leyendo como milisegundos, es decir, como un valor 1000 veces menor de lo que es, y la fecha calculada salta a los alrededores de 1970.
También existe el error en sentido contrario. Si confundes un número en milisegundos con segundos, lo multiplicas por 1000 y lo pasas a Date, el resultado salta a un futuro 1000 veces más lejano que la fecha real. En ambos casos el código se ejecuta sin ningún error, así que es difícil darse cuenta hasta que ves una fecha rara en pantalla.
Cómo identificar la unidad a mano, solo contando dígitos
La regla de identificación y por qué 11 dígitos marcan el límite
La regla es la siguiente: cuenta los dígitos de la parte entera y, si son de 1 a 11, son segundos; de 12 a 14, milisegundos; de 15 a 17, microsegundos; y de 18 en adelante, nanosegundos.
El límite está en 11 dígitos por una razón: 99999999999, el valor máximo de 11 dígitos, convertido a segundos da el 16 de noviembre del año 5138.
Es decir, un timestamp en segundos puede representar hasta el año 5138 con solo 11 dígitos, así que, si te aparece un número de 12 dígitos o más, lo más probable es que no esté en segundos sino en una unidad más pequeña.
Comprobación con números reales
Vamos a comprobarlo con números reales. En el momento de escribir este artículo, el timestamp en segundos es 1784298258 (10 dígitos) y, interpretado correctamente como segundos, corresponde al 17 de julio de 2026, 14:24 (UTC).
Sin embargo, si por error pasas ese número directamente a la posición de los milisegundos, como en new Date(1784298258), el resultado es el 21 de enero de 1970. Y es que 1784298258 milisegundos son apenas unos 20 días.
El valor en milisegundos del mismo instante es 1784298258087 (13 dígitos). Si lo confundes con segundos, lo multiplicas por 1000 y lo pasas como new Date(1784298258087 * 1000), el resultado es el año 58512, una fecha imposible.
El orden de los cálculos
El orden de los cálculos es el siguiente.
- Cuenta los dígitos del número.
- Decide la unidad según la regla de dígitos (límites de 11 / 14 / 17 dígitos).
- Si está en milisegundos, divide entre 1000 para pasarlo a segundos; si quieres meter segundos en un Date de JavaScript, multiplica por 1000 para convertirlos en milisegundos.
- Comprueba el objeto Date resultante con toISOString() (UTC) y toString() (hora local).
En vez de contar dígitos y repetir divisiones y multiplicaciones a mano, compruébalo con nuestra herramienta gratuita, el «Conversor Epoch de precisión: de segundos a nanosegundos».
Detecta el número de dígitos automáticamente y calcula al instante la equivalencia en segundos, milisegundos, microsegundos y nanosegundos, además de la hora UTC y la local. Es gratis y todo se procesa solo en el navegador.

Puntos que suelen generar confusión
Un mismo instante tiene un número de dígitos distinto según la unidad. Esta tabla resume los números que acabamos de verificar.
| Dígitos | Unidad | Valor de ejemplo | Momento al que apunta (UTC) |
|---|---|---|---|
| 1 a 11 dígitos | segundos | 1784298258 | 2026-07-17 14:24:18 |
| 12 a 14 dígitos | milisegundos | 1784298258087 | 2026-07-17 14:24:18.087 |
| 15 a 17 dígitos | microsegundos | 1784298258087000 | 2026-07-17 14:24:18.087 (el mismo instante) |
| 18 dígitos o más | nanosegundos | 1784298258087000000 | 2026-07-17 14:24:18.087 (el mismo instante) |
Diferencia entre UTC, hora local y tiempo relativo
La razón por la que UTC y la hora local se ven distintos es que el timestamp en sí no pertenece a ninguna zona horaria: es un valor absoluto (el tiempo transcurrido desde las 0:00 del 1 de enero de 1970 UTC). La hora local es ese valor absoluto más el desfase de la zona horaria que tenga configurada el navegador.
Por ejemplo, el valor de la tabla anterior corresponde al 17 de julio a las 14:24 en UTC, pero en una zona horaria como UTC+9 ese mismo instante se muestra como las 23:24 del 17 de julio.
El tiempo relativo (indicaciones como «dentro de 3 horas») se obtiene calculando en segundos la diferencia entre el momento de destino y el momento actual, y luego convirtiéndola a la unidad más fácil de leer: minutos, horas o días. Si el destino está en el futuro se añade «dentro de», y si está en el pasado, «hace».
Timestamps negativos y unidades calculadas
Los timestamps negativos también son válidos. Un valor negativo indica un momento anterior a las 0:00 del 1 de enero de 1970 (UTC). Por ejemplo, -3600 apunta a las 23:00 (UTC) del 31 de diciembre de 1969, es decir, 3600 segundos (1 hora) antes de esa referencia.
Por último, conviene tener en cuenta que los valores en microsegundos y nanosegundos son valores calculados: se obtienen multiplicando el valor en milisegundos por 1000 y por 1.000.000, respectivamente. Si el sistema de origen midió de verdad de forma independiente hasta el microsegundo, los dígitos inferiores de ese valor original pueden no coincidir con este cálculo.
Conclusión
- De 1 a 11 dígitos son segundos, de 12 a 14 dígitos son milisegundos, de 15 a 17 dígitos son microsegundos y 18 dígitos o más son nanosegundos.
- El valor máximo de un timestamp en segundos de 11 dígitos apenas llega al año 5138, así que, si tiene 12 dígitos o más, lo más probable es que no esté en segundos.
- Si pasas un valor en segundos de 10 dígitos tal cual a la posición de los milisegundos, obtienes algo cercano a 1970; y si confundes un valor en milisegundos de 13 dígitos con segundos y lo multiplicas por 1000, obtienes un futuro absurdo.
- Un mismo timestamp se muestra distinto en UTC y en hora local según el desfase horario, y un valor negativo indica un momento anterior a 1970.
- Los valores en microsegundos y nanosegundos son valores calculados multiplicando el valor en milisegundos.
Detecta el número de dígitos automáticamente y calcula al instante la equivalencia en segundos, milisegundos, microsegundos y nanosegundos, además de la hora UTC y la local. Es gratis y todo se procesa solo en el navegador.
Preguntas frecuentes
¿La regla de los dígitos basta para estar siempre seguro de la unidad?
Si se trata de timestamps de trabajo diario con años cercanos al actual, la regla sirve de sobra para distinguirlos. Eso sí, es un método convencional basado en el cálculo de que «un valor en segundos se representa con 11 dígitos hasta el año 5138»; si el valor en segundos apunta a un futuro mucho más lejano, puede tener 12 dígitos o más y la regla fallaría.
¿Puedo introducir un timestamp negativo?
Sí, los valores negativos que representan fechas anteriores al 1 de enero de 1970 también se calculan con normalidad. Por ejemplo, -3600 corresponde a las 23:00 (UTC) del 31 de diciembre de 1969.
¿El número que escribo se envía a un servidor?
No. Toda la detección de unidades y el cálculo de fechas se procesan al instante dentro del navegador con JavaScript, y el número que introduces no se envía a ningún servidor.
¿Los valores en microsegundos y nanosegundos son tan precisos como una medición real?
No. Los valores en microsegundos y nanosegundos que se muestran son valores calculados multiplicando el valor en milisegundos por 1000 y por 1.000.000. Si el sistema de origen midió de verdad de forma independiente hasta el microsegundo, sus dígitos inferiores pueden ser distintos.
Este artículo está adaptado de nuestro original en coreano. Leer el original en coreano