MakeTimestamp logo
MakeTimestamp

Guías

Convertidor de Timestamp a ISO 8601 (Segundos, Milisegundos, Nanosegundos)

Por qué esta página

A menudo recibes timestamps en segundos (10 dígitos), milisegundos (13), microsegundos (16) o nanosegundos (19). Esta página te da reglas completas, fragmentos listos para usar y enlaces al convertidor completo para que puedas transformar cualquier epoch a ISO 8601 / RFC 3339 sin adivinar la precisión.

Inicio rápido (flujo MVP)

  1. Pega el timestamp (detectamos automáticamente longitud y precisión).
  2. Elige zona horaria: UTC o desplazamiento personalizado (ej., UTC+01:00).
  3. Obtén salida ISO 8601 / RFC 3339, luego copia con un clic.
  4. ¿Necesitas integrarlo? Copia un fragmento de código abajo.

Prueba la herramienta interactiva: Convertidor Timestamp → ISO y Constructor de Formato.

Reglas de entrada y validación

  • Detección de longitud: 10=segundos, 13=ms, 16=µs, 19=ns.
  • Caracteres permitidos: solo dígitos; rechaza espacios y letras.
  • Rango: debe estar dentro de límites seguros de plataforma (revisa 32-bit vs 64-bit; ver FAQ).
  • Zona horaria: UTC por defecto; desplazamientos personalizados como +01:00, -05:30.
  • DST: la salida usa ISO 8601 con desplazamiento; UTC evita sorpresas de DST.

Fragmentos de código

JavaScript / Node.js

const detectarPrecision = (raw) => {
  const len = raw.length;
  if (len === 10) return { value: Number(raw) * 1000, unit: "ms" };
  if (len === 13) return { value: Number(raw), unit: "ms" };
  if (len === 16) return { value: Number(raw) / 1000, unit: "ms" }; // µs → ms
  if (len === 19) return { value: Number(raw) / 1_000_000, unit: "ms" }; // ns → ms
  throw new Error("Longitud inválida");
};

const aIso = (raw, tz = "UTC") => {
  const { value } = detectarPrecision(raw);
  return new Date(value).toISOString(); // Compatible RFC 3339
};

console.log(aIso("1704067200"));      // 10 dígitos -> segundos
console.log(aIso("1704067200000"));   // 13 dígitos -> milisegundos

Python

from datetime import datetime, timezone, timedelta

def a_iso(raw: str, offset_minutos: int = 0) -> str:
    longitud = len(raw)
    if longitud == 10:
        ts = int(raw)
    elif longitud == 13:
        ts = int(raw) / 1000
    elif longitud == 16:
        ts = int(raw) / 1_000_000
    elif longitud == 19:
        ts = int(raw) / 1_000_000_000
    else:
        raise ValueError("Longitud inválida")

    tz = timezone(timedelta(minutes=offset_minutos))
    return datetime.fromtimestamp(ts, tz=tz).isoformat()

print(a_iso("1704067200", 0))     # UTC
print(a_iso("1704067200000", 60)) # UTC+01:00

Go

package main

import (
    "fmt"
    "strconv"
    "time"
)

func parseEpoch(raw string) (time.Time, error) {
    switch len(raw) {
    case 10:
        sec, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(sec, 0).UTC(), nil
    case 13:
        ms, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(0, ms*int64(time.Millisecond)).UTC(), nil
    case 16:
        us, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(0, us*int64(time.Microsecond)).UTC(), nil
    case 19:
        ns, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(0, ns).UTC(), nil
    }
    return time.Time{}, fmt.Errorf("longitud inválida")
}

func main() {
    t, _ := parseEpoch("1704067200")
    fmt.Println(t.Format(time.RFC3339)) // 2024-01-01T00:00:00Z
}

FAQ

  • ¿Qué pasa si no conozco la precisión? Cuenta los dígitos: 10=s, 13=ms, 16=µs, 19=ns.
  • ¿Debería siempre usar UTC? Sí para almacenamiento; convierte a hora local solo para mostrar.
  • ¿Esto maneja años bisiestos y DST? Sí, las bibliotecas de fecha lo manejan automáticamente.

Herramientas y guías relacionadas