Convertidor de Timestamp Unix

Convierte timestamps Unix individuales o por lotes (s, ms, µs, ns) y fechas ISO-8601 o RFC 3339 entre UTC, hora local y zonas horarias IANA en tu navegador.

Sin subidasSin registroResultados instantáneos
Segundos, ms, µs y nsZonas horarias IANA y por lotes100% Local • Cero Subidas
Convertir marca de tiempo Unix
Motor local listoEspacio de trabajo 100% privado en el navegador • Sin subidas a la nube
100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Convertidor de Timestamp Unix gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Autodetección de Precisión y Matemática BigInt de 64 Bits

Clasifica segundos de 10 dígitos, milisegundos de 13, microsegundos de 16 y nanosegundos de 19 dígitos automáticamente mediante división BigInt de 64 bits para que las fracciones de segundo nunca sufran redondeo float64 IEEE-754.

Salida en ISO-8601, RFC 3339 y RFC 2822

Renderiza cada instante convertido simultáneamente en formato canónico ISO-8601 UTC, RFC 3339 con desplazamientos numéricos de zona horaria explícitos, cabeceras RFC 2822 / IMF-fixdate y tiempo relativo.

Procesamiento por Lotes y Zonas Horarias IANA

Analiza cientos de enteros Unix separados por saltos de línea o cadenas de fecha en una sola pasada y proyecta los timestamps en cualquier región de la base de datos IANA aplicando reglas históricas de horario de verano (DST).

Privacidad Local sin Subida de Datos

Ejecuta todo el análisis sintáctico, la aritmética BigInt y las consultas de zona horaria con Intl.DateTimeFormat localmente en la memoria del navegador: las trazas y registros de auditoría de producción nunca salen de tu equipo.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Autodetección de Precisión y Matemática BigInt de 64 Bits Clasifica segundos de 10 dígitos, milisegundos de 13, microsegundos de 16 y nanosegundos de 19 dígitos automáticamente mediante división BigInt de 64 bits para que las fracciones de segundo nunca sufran redondeo float64 IEEE-754. Opciones limitadas sin personalización avanzada
Salida en ISO-8601, RFC 3339 y RFC 2822 Renderiza cada instante convertido simultáneamente en formato canónico ISO-8601 UTC, RFC 3339 con desplazamientos numéricos de zona horaria explícitos, cabeceras RFC 2822 / IMF-fixdate y tiempo relativo. Requiere herramientas externas o ajustes manuales
Privacidad y Procesamiento 100% local en tu navegador (cero subidas al servidor) Sube los datos a servidores externos en la nube
Precio y Registro 100% gratis para siempre y sin crear cuenta Requiere registro de cuenta o suscripción de pago
Cómo funciona

Cómo usar Convertidor de Timestamp Unix en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Pega o Sube Timestamps o Fechas en Formato de Red

Introduce un único timestamp Unix, pega una cadena de fecha ISO-8601, RFC 3339 o RFC 2822, o sube una lista separada por saltos de línea de valores numéricos extraídos de logs o exportaciones de bases de datos.

2

Confirma la Unidad de Precisión y la Zona Horaria Destino

Deja que la detección por rango de dígitos infiera segundos (10 dígitos), milisegundos (13), microsegundos (16) o nanosegundos (19), o fija una unidad explícita y selecciona una zona horaria IANA como America/New_York o Europe/Madrid.

3

Copia Formatos Normalizados o Resultados por Lotes

Copia representaciones individuales en ISO-8601, RFC 3339, RFC 2822, UTC o enteros en distintas unidades, o exporta las filas del lote convertido directamente al portapapeles.

Conversión de Timestamps Unix Multiprecisión y por Lotes

Respuesta rápida: Pega enteros individuales o separados por saltos de línea en segundos, milisegundos, microsegundos o nanosegundos —o cadenas ISO-8601 y RFC 3339— para convertirlos bidireccionalmente entre UTC, hora local y cualquier zona horaria IANA sin pérdida de precisión de coma flotante.

Los sistemas distribuidos modernos emiten timestamps Unix con cuatro niveles distintos de precisión según el entorno de ejecución y la capa de telemetría: las herramientas POSIX y los claims exp/iat de JWT emiten segundos de 10 dígitos, Date.now() en JavaScript e Instant.toEpochMilli() en Java emiten milisegundos de 13 dígitos, las estructuras internas de PostgreSQL y datetime en Python almacenan microsegundos de 16 dígitos, y las trazas de OpenTelemetry, time.UnixNano() en Go y clock_gettime(CLOCK_REALTIME) en Linux emiten nanosegundos de 19 dígitos.

Cuando pegas un timestamp en nanosegundos de 19 dígitos como 1784125800452819307 y seleccionas America/New_York como zona horaria IANA de destino, el convertidor separa el cociente entero y el resto subsegundo mediante aritmética BigInt de 64 bits y genera todos los formatos de transmisión y unidades escaladas simultáneamente:

{
  "input": "1784125800452819307",
  "detectedUnit": "nanoseconds (19-digit)",
  "iso8601Utc": "2026-07-15T14:30:00.452819307Z",
  "rfc3339TargetTz": "2026-07-15T10:30:00.452819307-04:00",
  "targetTimezone": "America/New_York (EDT, UTC-04:00)",
  "rfc2822Utc": "Wed, 15 Jul 2026 14:30:00 +0000",
  "units": {
    "seconds": "1784125800",
    "milliseconds": "1784125800452",
    "microseconds": "1784125800452819",
    "nanoseconds": "1784125800452819307"
  }
}

Para el triaje de logs y migraciones de bases de datos, pega filas separadas por saltos de línea combinando enteros en distintas precisiones, valores negativos previos a 1970 y cadenas RFC 3339 para obtener una normalización bidireccional en una sola pasada:

# Entrada (lote mixto separado por saltos de línea)
1784125800
1784125800452
1784125800452819307
-14182940
2026-07-15T23:30:00+09:00

# Salida Normalizada (ISO-8601 UTC | Segundos Unix | Formato Detectado)
2026-07-15T14:30:00Z            | 1784125800 | seconds (10-digit)
2026-07-15T14:30:00.452Z        | 1784125800 | milliseconds (13-digit)
2026-07-15T14:30:00.452819307Z  | 1784125800 | nanoseconds (19-digit)
1969-07-20T20:17:40Z            | -14182940  | seconds (signed pre-1970)
2026-07-15T14:30:00Z            | 1784125800 | RFC 3339 / ISO-8601 string

Especificación del Tiempo Unix, Umbrales de Precisión y Casos Límite

Respuesta rápida: El tiempo Unix POSIX cuenta los segundos sin segundos intercalares transcurridos desde 1970-01-01T00:00:00Z a razón de exactamente 86.400 segundos por día UTC. La conversión sin pérdidas entre múltiples unidades requiere clasificación por bandas de magnitud, división BigInt de 64 bits, división entera euclidiana para valores negativos anteriores a 1970 y resolución histórica de desplazamientos mediante la base de datos tzdb de IANA.

Definición POSIX y Segundos Intercalares (Leap Seconds)

Según el estándar POSIX.1-2017 (Base Definitions, Section 4.16: Seconds Since the Epoch), el tiempo Unix no se define como un recuento bruto de segundos atómicos del SI transcurridos, sino mediante una fórmula determinista que asigna a cada día del calendario UTC exactamente 86,400 segundos. A diferencia del Tiempo Atómico Internacional (TAI), que actualmente va 37 segundos por delante de UTC, los timestamps Unix POSIX omiten los segundos intercalares. Cada vez que el IERS inserta un segundo intercalar positivo (23:59:60Z), los sistemas operativos retrasan el reloj un segundo o distribuyen ese segundo extra a lo largo de una ventana de varias horas mediante leap smearing en NTP. En consecuencia, un entero Unix numérico no puede codificar de forma unívoca 23:59:60Z sin el contexto de una tabla externa de segundos intercalares.

Truncamiento Float64 IEEE-754 frente a Aritmética BigInt de 64 Bits

Los números en JavaScript utilizan coma flotante de doble precisión IEEE-754 (binary64), que asigna 53 bits de mantisa y limita la representación exacta de enteros a Number.MAX_SAFE_INTEGER (9007199254740991, 16 dígitos). Un timestamp en nanosegundos de 19 dígitos como 1784125800452819307 supera 2^60 (1152921504606846976), donde el espaciado (ULP) entre valores flotantes IEEE-754 adyacentes representables se amplía a 256 nanosegundos:

Entero exacto de 64 bits:       1784125800452819307 -> .452819307Z
Coerción Number() de JS:        1784125800452819200 -> .452819200Z (¡107 ns perdidos!)

Para evitar la corrupción silenciosa por debajo del microsegundo, este convertidor analiza la entrada numérica directamente como BigInt, divide por el divisor de la unidad (1n, 1000n, 1000000n o 1000000000n) para extraer los segundos completos y formatea el resto BigInt directamente en dígitos fraccionarios rellenados con ceros.

Heurística de Bandas de Dígitos, División Euclidiana Pre-1970 y el Efecto 2038

La detección automática clasifica las magnitudes absolutas inferiores a 10^11 como segundos (cubriendo desde 1970-01-01 hasta 5138-11-16), de 10^11 a 10^14 - 1 como milisegundos, de 10^14 a 10^17 - 1 como microsegundos y 10^17 o superior como nanosegundos. Para enteros pequeños cercanos al origen de 1970 (por ejemplo 86400, que equivale a 1970-01-02T00:00:00Z en segundos o a 1970-01-01T00:01:26.400Z en milisegundos), fija el selector de unidad explícitamente.

Dos casos límite de enteros con signo suelen romper los convertidores convencionales:

  • Desbordamiento de time_t de 32 bits con signo (Y2038): Los enteros con signo heredados de 32 bits alcanzan su máximo en 2147483647 (2038-01-19T03:14:07Z), desbordándose en el segundo siguiente a -2147483648 (1901-12-13T20:45:52Z). Los sistemas modernos y la lógica BigInt de 64 bits evitan este límite por completo.
  • División entera euclidiana en subsegundos negativos: En ISO-8601, los dígitos fraccionarios siempre suman hacia adelante a partir del segundo entero redondeado hacia abajo (floor). Para -14182939750 ms (250 ms después de 1969-07-20T20:17:40Z), la división por truncamiento produce -14182939 s con resto -750 ms, mientras que la división euclidiana hacia abajo resuelve correctamente -14182940 s más +250 ms (1969-07-20T20:17:40.250Z).

Gramáticas de Red: ISO-8601 vs RFC 3339 vs RFC 2822

Mientras que ISO-8601 permite fechas por semana (2026-W29-3), fechas ordinales y designadores de zona horaria omitidos, RFC 3339 define un perfil estricto para Internet que exige el timestamp completo YYYY-MM-DDTHH:MM:SS[.fraction] más un sufijo explícito Z o un desplazamiento numérico ±HH:MM. RFC 2822 (actualizado por RFC 5322) especifica la sintaxis descriptiva Wed, 15 Jul 2026 14:30:00 +0000 que sigue siendo obligatoria en cabeceras de correo SMTP y en los campos HTTP Last-Modified / Date de tipo IMF-fixdate.

Convertidor de Timestamp Unix vs Convertidor Epoch: ¿Cuál Necesitas?

Respuesta rápida: Usa el Convertidor de Timestamp Unix para decodificar, normalizar o convertir por lotes enteros en s, ms, µs y ns y cadenas ISO-8601 o RFC 3339 entre zonas horarias IANA. Cambia al Convertidor Epoch cuando necesites un reloj Unix en vivo, un constructor de fechas A/M/D/H/M/S, tablas de límites de día/semana/mes/año, cálculo de deltas de duración o fragmentos de código por lenguaje.

Ambas utilidades de tiempo de Utiliome se ejecutan íntegramente en el navegador del cliente, pero están orientadas a flujos de trabajo de ingeniería distintos. El Convertidor de Timestamp Unix está diseñado para decodificar y normalizar por lotes cargas útiles de red —como timestamps de trazas en nanosegundos de OpenTelemetry, cabeceras de mensajes de Kafka, claims de JWT y extractos de logs multilínea—. Si por el contrario estás redactando consultas por rangos de tiempo, calculando la duración transcurrida en un incidente o escribiendo código de manejo de fechas, abre la herramienta complementaria Convertidor Epoch.

Capacidad Convertidor de Timestamp Unix Convertidor Epoch
Flujo de trabajo principal Decodificar y convertir por lotes timestamps numéricos y cadenas de fecha Construir timestamps desde campos de calendario, consultar límites de periodos y calcular deltas
Precisión subsegundo Autodetecta segundos (10), ms (13), µs (16) y ns con BigInt de 64 bits (19) Segundos y milisegundos para relojes, constructores y límites de consultas
Procesamiento por lotes multilínea Sí — convierte listas multilínea mixtas de timestamps y fechas ISO-8601 Banco de trabajo de fecha de referencia única y comparación delta entre dos timestamps
Reloj Unix en tiempo real No es el foco — optimizado para inspección determinista de payloads Sí — contador en tiempo real con captura de pausa/congelación
Límites de inicio y fin de periodo Convierte únicamente instantes individuales Precalcula valores de inicio y fin para día, semana ISO, mes y año
Cálculo de delta entre dos timestamps Muestra el desplazamiento relativo respecto al reloj actual Desglose completo de delta T2 - T1 (d/h/m/s/ms + ISO-8601 PnDTnHnMnS)
Fragmentos de código por lenguaje Salidas en formatos de transmisión (ISO-8601, RFC 3339, RFC 2822) Snippets listos para copiar en JS, Python, Go, Rust, SQL y Bash

¿Necesitas los enteros de inicio de día y fin de mes para una cláusula WHERE en SQL, el delta exacto entre dos marcas de tiempo de un incidente o una línea de código lista para copiar en Go/Rust/SQL? Pásate por el Convertidor Epoch.

Preguntas frecuentes

Preguntas frecuentes y guía técnica de Convertidor de Timestamp Unix

Todo lo que necesitas saber sobre el uso gratuito en línea de convertidor de timestamp unix a fecha en Utiliome.

¿Cómo distingue la detección automática de precisión entre segundos, milisegundos, microsegundos y nanosegundos?

El analizador elimina los espacios en blanco, evalúa la magnitud entera absoluta mediante BigInt y clasifica los valores por bandas de potencias de diez: las magnitudes inferiores a 10^11 corresponden a segundos (fechas hasta el año 5138), de 10^11 a 10^14 - 1 corresponden a milisegundos, de 10^14 a 10^17 - 1 a microsegundos, y 10^17 o superior a nanosegundos. Si estás inspeccionando enteros subsegundo pequeños registrados poco después del 1970-01-01, anula la detección automática seleccionando una unidad explícita.

¿Por qué los timestamps en nanosegundos de 19 dígitos pierden precisión en las llamadas estándar a Date() en JavaScript?

El estándar de JavaScript tiene dos limitaciones: los objetos Date solo almacenan milisegundos enteros internamente, y los valores Number de JavaScript usan coma flotante IEEE-754 de 64 bits cuya mantisa de 53 bits pierde precisión entera por encima de Number.MAX_SAFE_INTEGER (9007199254740991). En el orden de 10^18 nanosegundos, float64 redondea los enteros a múltiplos de 256 ns. Esta herramienta evita la coerción a Number durante el análisis utilizando división BigInt de 64 bits y formateo del resto para conservar los 9 dígitos fraccionarios de nanosegundos.

¿Cómo se procesan los timestamps Unix negativos anteriores al 1 de enero de 1970?

Los enteros negativos cuentan segundos (o unidades subsegundo) hacia atrás desde 1970-01-01T00:00:00Z; por ejemplo, -14182940 segundos equivale a 1969-07-20T20:17:40Z. Para entradas negativas con fracciones de segundo como -14182939750 milisegundos, el convertidor aplica la división entera euclidiana (-14182940 segundos más +250 milisegundos) para que la salida ISO-8601 muestre con exactitud 1969-07-20T20:17:40.250Z sin errores de desfase de un segundo.

¿Cuál es la diferencia entre los formatos de salida ISO-8601, RFC 3339 y RFC 2822?

ISO-8601 es el estándar internacional general que abarca fechas de calendario, fechas ordinales, fechas por semana e intervalos. RFC 3339 es un perfil estricto de Internet basado en ISO-8601 utilizado en APIs JSON, manifiestos de Kubernetes y logs estructurados que exige un timestamp completo YYYY-MM-DDTHH:MM:SS con un sufijo explícito Z o desplazamiento UTC ±HH:MM. RFC 2822 (y RFC 5322 / IMF-fixdate en HTTP) es la sintaxis de cabecera legible por humanos, como Wed, 15 Jul 2026 14:30:00 +0000, utilizada en correos electrónicos y cabeceras HTTP.

¿La conversión de zonas horarias IANA aplica las reglas históricas de horario de verano (DST)?

Sí. Al seleccionar una región como America/New_York, Europe/Berlin o Australia/Sydney, se consulta la base de datos de zonas horarias IANA integrada en el navegador mediante Intl.DateTimeFormat para el instante histórico o futuro exacto que se está convirtiendo, aplicando EDT (-04:00) a un timestamp de julio y EST (-05:00) a uno de enero, en lugar de aplicar uniformemente el desplazamiento local actual.