Formatos de timestamp Unix explicados

Una referencia completa de todos los formatos de timestamp Unix — segundos, milisegundos, microsegundos, ISO 8601 y RFC 2822 — con ejemplos que muestran qué formato usa cada lenguaje y base de datos.

Unix time en segundos — el formato universal

El formato más común: un entero de 32 o 64 bits que cuenta los segundos enteros desde el 1 de enero de 1970 00:00:00 UTC. Actualmente un número de 10 dígitos en torno a 1700 millones.

  • Ejemplo: 1700000000 = 2023-11-15 06:13:20 UTC
  • Usado por: Python time.time(), PHP time(), Go time.Now().Unix(), Ruby Time.now.to_i, C time(NULL)
  • Se almacena como: int de 32 bits (heredado, año máx. 2038), int de 64 bits (moderno, seguro por miles de millones de años)
  • Base de datos: MySQL UNIX_TIMESTAMP(), PostgreSQL EXTRACT(EPOCH FROM NOW())::BIGINT

Unix time en milisegundos — el formato de JavaScript

Milisegundos desde el epoch Unix: un entero de 13 dígitos con precisión de milisegundo. Es el formato que el objeto Date de JavaScript usa internamente.

  • Ejemplo: 1700000000000 = 2023-11-15 06:13:20.000 UTC
  • Usado por: JavaScript Date.now(), Java System.currentTimeMillis(), .NET DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
  • Para convertir a segundos: Math.floor(ms / 1000)
  • Para convertir desde segundos: seconds * 1000

ISO 8601 — el estándar legible por humanos

ISO 8601 es un estándar internacional para representar fechas y horas como cadenas. A diferencia de los timestamps Unix, es autodescriptivo: el formato codifica la fecha/hora y el desfase de zona horaria.

  • 2023-11-15T06:13:20Z — UTC (el sufijo Z significa UTC)
  • 2023-11-15T01:13:20-05:00 — con desfase UTC explícito (EST)
  • 2023-11-15T06:13:20.000Z — con milisegundos
  • JavaScript: date.toISOString() siempre devuelve UTC con sufijo Z
  • Python: datetime.isoformat(), Go: time.Format(time.RFC3339)

RFC 2822 — formato de fecha de correo y HTTP

RFC 2822 (también llamado RFC 1123 para HTTP) es el formato de fecha usado en cabeceras de correo y respuestas HTTP. El método Date.toUTCString() de JavaScript devuelve este formato.

  • Ejemplo: Wed, 15 Nov 2023 06:13:20 GMT
  • Usado en: cabeceras de respuesta HTTP (Last-Modified, Date, Expires), cabeceras de correo (Date:)
  • JavaScript: date.toUTCString()
  • Menos común en APIs modernas, pero aún muy presente en la infraestructura web

Cómo detectar el formato del timestamp

Cuando recibes un valor de timestamp desconocido, usa estas reglas para identificar su formato:

  • 10 dígitos, empieza por 1 → segundos Unix (p. ej. 1700000000)
  • 13 dígitos, empieza por 1 → milisegundos Unix (p. ej. 1700000000000)
  • Negativo → segundos o milisegundos Unix anteriores a 1970
  • Contiene T o Z → ISO 8601 (p. ej. 2023-11-15T06:13:20Z)
  • Contiene una coma o nombre de día → RFC 2822 (p. ej. Wed, 15 Nov 2023 ...)
  • 16 dígitos → microsegundos (divide entre 1,000,000 para segundos)
  • 19 dígitos → nanosegundos (divide entre 1,000,000,000 para segundos)

Microsegundos y nanosegundos

Algunos sistemas de alta precisión usan unidades menores que el milisegundo. Son raras en código de aplicación, pero aparecen en sistemas de bajo nivel, internos de bases de datos y herramientas de observabilidad.

  • Microsegundos (µs): entero de 16 dígitos — Rust SystemTime as_micros(), PostgreSQL clock_gettime()
  • Nanosegundos (ns): entero de 19 dígitos — Go time.Now().UnixNano(), Rust SystemTime as_nanos()
  • PostgreSQL EXTRACT(EPOCH) devuelve un número de coma flotante con los microsegundos como parte fraccionaria
  • Para convertir nanosegundos a segundos: divide entre 1,000,000,000 (1e9)

Preguntas frecuentes sobre formatos de timestamp Unix

¿Cuántos dígitos tiene un timestamp Unix?
Un timestamp Unix moderno en segundos tiene 10 dígitos (en torno a 1700 millones); en milisegundos, 13. Los microsegundos tienen 16 dígitos y los nanosegundos 19.
¿Cuál es la diferencia entre Unix time e ISO 8601?
Unix time es un único número de segundos o milisegundos desde 1970 UTC y no lleva zona horaria. ISO 8601 es una cadena autodescriptiva como 2023-11-15T06:13:20Z que codifica fecha, hora y desfase.
¿Cómo detecto si un timestamp está en segundos o milisegundos?
Cuenta los dígitos: 10 son segundos y 13 son milisegundos. Si un valor se convierte en una fecha cercana a 1970 o muy lejana, la unidad se interpretó mal.