Unix Timestamp en segundos vs milisegundos: por qué la fecha sale 1970

Convertiste un timestamp a fecha y caíste en enero de 1970. Casi nunca es un reloj roto. El número se leyó como milisegundos cuando estaba en segundos—o al revés.

¿Qué es un Unix timestamp?

Un Unix timestamp mide el tiempo desde el Unix epoch: 1970-01-01 00:00:00 UTC. Suele usar segundos enteros. El mismo instante puede guardarse en milisegundos (segundos × 1.000). El número no indica la unidad.

Segundos vs milisegundos: la diferencia ×1.000

Un segundo son 1.000 milisegundos. Compara 1720000000 con 1720000000000. Si el primero es segundos y el segundo milisegundos, marcan el mismo instante. Si lees el primero como milisegundos, la fecha salta hacia 1970.

Estos resultados UTC se calcularon con los números de arriba; no son una estimación.

Valor	Unidad probable	Interpretación (UTC)
1720000000	Segundos	Fecha moderna leída como segundos: 2024-07-03 09:46:40 UTC
1720000000000	Milisegundos	El mismo instante leído como milisegundos: 2024-07-03 09:46:40 UTC
1720000000 como milisegundos	Unidad incorrecta	Fecha cerca de 1970: 1970-01-20 21:46:40 UTC

¿Por qué mi timestamp muestra 1970?

Si un valor en segundos se trata como milisegundos, el número es 1.000 veces más pequeño de lo necesario. JavaScript cuenta solo un tramo corto tras el Unix epoch, y la fecha queda en 1970:

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

Esa fecha de 1970 es el epoch más un par de semanas. Multiplica los segundos por 1.000 antes de pasarlos a Date.

• SEGUNDOS
• 1720000000
• × 1000
• ↓
• MILISEGUNDOS
• 1720000000000

• Valor en segundos
• ↓
• Tratado por error como milisegundos
• ↓
• Fecha cerca de 1970

¿10 dígitos son segundos y 13 dígitos milisegundos?

En fechas actuales, 10 dígitos suelen ser segundos y 13 milisegundos. Es una pista rápida, no una regla de validación. El número de dígitos cambia con el rango temporal, y algunas APIs guardan microsegundos o nanosegundos. Confirma la unidad con la documentación o con una fecha que tenga sentido.

Por qué pasa tanto en JavaScript

En JavaScript, un Date numérico son milisegundos desde el epoch. Muchos backends, bases de datos y herramientas Unix siguen guardando segundos. Pasar un valor en segundos directo a Date es un error frecuente:

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong queda cerca de 1970 (1970-01-20 21:46:40 UTC). correct es el instante moderno (2024-07-03 09:46:40 UTC).

Otros sistemas usan unidades distintas

Otros lenguajes, APIs y bases de datos pueden usar segundos o milisegundos. Algunos guardan microsegundos o nanosegundos. No asumas que un lenguaje usa siempre una unidad: mira la documentación. Si el número está en JSON, Formatear y comparar JSON ayuda a leer el campo; no te dirá la unidad.

¿Cómo saber qué unidad usa mi timestamp?

Sigue estas comprobaciones en orden. La cantidad de dígitos no basta.

1. Consulta la documentación de la API o de la base de datos.
2. Mira el número aproximado de dígitos.
3. Compara el valor con un timestamp moderno plausible.
4. Prueba el valor como segundos y como milisegundos.
5. Comprueba si la fecha resultante tiene sentido.

Si una interpretación cae en 1970 y la otra en una fecha que reconoces, la causa es el desajuste de unidades.

Errores habituales con Unix timestamp

• Segundos interpretados como milisegundos. La fecha se pliega hacia 1970, como en el ejemplo.
• Milisegundos interpretados como segundos. La fecha salta al futuro lejano, o la conversión falla.
• Multiplicar por 1.000 dos veces. Un valor que ya era milisegundos se vuelve enorme y la fecha avanza siglos.
• Dividir por 1.000 dos veces. Un valor en segundos se encoge otra vez, otra vez cerca de 1970.
• Culpar a la zona horaria. Una zona puede mover horas o el día del calendario. No lleva un timestamp moderno a 1970.
• Tratar una fecha formateada como Unix timestamp. Un valor como 2024-07-03T09:46:40Z no es un número epoch. Pársalo como fecha, no como segundos.

¿La zona horaria causa el problema de 1970?

Normalmente, no. Una zona horaria puede cambiar el reloj mostrado y, cerca de medianoche, la fecha del calendario. No convierte un Unix timestamp moderno en 1970. Si el resultado es 1970, mira primero segundos frente a milisegundos.

Convertir y comprobar un Unix timestamp

NEXNARA Convertidor de fecha y hora puede convertir un Unix timestamp en el navegador.

Pega segundos o milisegundos Unix, usa el timestamp actual, mira UTC y la hora local, convierte zonas horarias y formatea una fecha. La detección automática suele tratar 10 dígitos como segundos y 13 como milisegundos; aún puedes elegir la unidad.

La conversión ocurre en tu navegador. Esta herramienta no envía fechas ni timestamps a un servidor de NEXNARA. Los anuncios y otras funciones del sitio sí usan la red; eso es aparte de la conversión.

¿Quieres comprobar un Unix timestamp? Abre Convertidor de fecha y hora y compara segundos con milisegundos.

FAQ

¿Por qué mi Unix timestamp muestra 1970?

A menudo son segundos leídos como milisegundos. JavaScript trata un número mucho menor, así que la fecha queda poco después de 1970-01-01 00:00:00 UTC. Multiplica los segundos por 1.000 y vuelve a convertir.

¿Los Unix timestamp son segundos o milisegundos?

Suelen usar segundos. Muchas APIs web y Date en JavaScript usan milisegundos. Mira lo que documenta ese sistema. Algunos usan microsegundos o nanosegundos.

¿Cómo convierto segundos a milisegundos?

Multiplica por 1.000. 1720000000 segundos son 1720000000000 milisegundos. Al revés, divide por 1.000.

¿Por qué Date en JavaScript usa milisegundos?

El timestamp numérico de Date en JavaScript se define como milisegundos desde el Unix epoch. Por eso new Date(unixSeconds) es incorrecto si unixSeconds está en segundos Unix.

¿Un timestamp de 10 dígitos es siempre segundos?

No. En fechas actuales suele ser segundos, y 13 dígitos suelen ser milisegundos. El recuento de dígitos es una pista, no una regla. Confírmalo con la documentación o una fecha coherente.

¿Un Unix timestamp incluye zona horaria?

No. Un Unix timestamp es un instante contado desde 1970-01-01 00:00:00 UTC. Las zonas horarias afectan a cómo se muestra, no al número.