Hora Unix a fecha — convertir cualquier epoch en una fecha legible

La hora Unix a fecha en una línea

Aquí está toda la tarea en un ejemplo: el timestamp Unix 1700000000 se convierte en 2023-11-14T22:13:20Z — martes 14 de noviembre de 2023 a las 22:13:20 UTC. Un timestamp Unix cuenta los segundos desde el 1 de enero de 1970 UTC; convertirlo consiste en decodificar ese conteo como UTC y formatearlo en la zona horaria que necesites. Lo único que rompe las conversiones es la unidad: 10 dígitos son segundos, 13 milisegundos, 16 microsegundos. La tabla siguiente es la instrucción lista para copiar para cada lenguaje y herramienta de esta guía.

• Abrir el convertidor de timestamp Unix
• En sentido inverso — fecha a timestamp Unix

Qué significa convertir la hora Unix en una fecha

Un timestamp Unix es el número de segundos desde el 1 de enero de 1970 UTC. Para convertirlo en una fecha se decodifica como UTC y luego se formatea en cualquier zona horaria. Ese es todo el problema en una frase — el resto de esta guía es solo la sintaxis en cada lenguaje. Cada lenguaje de programación moderno incluye una función integrada que toma un valor epoch Unix y devuelve un objeto fecha; lo único que debes vigilar es si el lenguaje espera segundos (Python, PHP, Linux date), milisegundos (JavaScript Date) o microsegundos (PostgreSQL, BigQuery).

La regla rápida de conversión

Cuenta los dígitos de tu valor. Un número de 10 dígitos está en segundos Unix. Un número de 13 dígitos está en milisegundos Unix. Un número de 16 dígitos está en microsegundos Unix. La epoch Unix comenzó el 1 de enero de 1970 — así que los valores de 10 dígitos hoy (en 2026) empiezan por 17 o 18; los milisegundos empiezan por 175 o 176 seguidos de 10 dígitos; los microsegundos empiezan por 1758 o 1759. Detecta la unidad antes de pasar el valor a una función de conversión, y tu salida caerá en el día correcto en lugar de en 1970.

• 10 dígitos → segundos Unix (rango 2001 a 2286)
• 13 dígitos → milisegundos Unix (rango 2001 a 2286)
• 16 dígitos → microsegundos Unix (rango 2001 a 2286)
• Los números cercanos a 10^9 (1.000.000.000) son segundos anteriores a 2001 — siguen siendo hora Unix válida
• Los enteros negativos son fechas anteriores a 1970 — la mayoría de los lenguajes los manejan; verifícalo
• Los números por encima de 2^31 en columnas INT alcanzan el límite del año 2038 — ver más abajo

• Milisegundos vs segundos — la guía completa de unidades

Convertir la hora Unix en una fecha en JavaScript

El constructor Date de JavaScript espera milisegundos, así que un valor en segundos Unix debe multiplicarse primero por 1000. El resultado es un objeto Date; formatéalo con toISOString() para ISO 8601 en UTC, o con Intl.DateTimeFormat para una cadena legible con zona horaria. Pasa siempre una opción timeZone explícita — sin ella, JavaScript usa la zona horaria local del entorno, que difiere entre los portátiles de desarrollo y los servidores de producción.

• new Date(1700000000 * 1000).toISOString() // '2023-11-14T22:13:20.000Z'
• new Date(1700000000 * 1000).toLocaleString('en-US', { timeZone: 'America/New_York' }) // tz-aware
• new Date(1700000000000).toISOString() // milliseconds — no × 1000 needed
• new Intl.DateTimeFormat('en-US', { timeZone: 'Asia/Tokyo', dateStyle: 'full', timeStyle: 'long' }).format(new Date(ms))
• Detect unit at runtime: const toDate = ts => new Date(ts < 1e11 ? ts * 1000 : ts)

• MDN — constructor Date()
• Formateo de fechas correcto por zona horaria en JavaScript (guía complementaria)

Convertir la hora Unix en una fecha en Python

datetime.fromtimestamp(ts, tz=timezone.utc) es la conversión canónica en Python. El argumento tz es obligatorio para un resultado en UTC; sin él, Python devuelve el timestamp en la zona horaria local del sistema — una fuente frecuente de errores de desfase horario en servidores. utcfromtimestamp() está obsoleto desde Python 3.12 porque devolvía un datetime ingenuo fácil de usar mal. Para milisegundos, divide entre 1000; para microsegundos, entre 1.000.000 — Python acepta fracciones de segundo directamente.

• from datetime import datetime, timezone
• datetime.fromtimestamp(1700000000, tz=timezone.utc) # 2023-11-14 22:13:20+00:00
• datetime.fromtimestamp(1700000000.123, tz=timezone.utc) # fractional seconds work
• datetime.fromtimestamp(ms / 1000, tz=timezone.utc) # from milliseconds
• datetime.fromtimestamp(us / 1_000_000, tz=timezone.utc) # from microseconds
• Avoid: datetime.utcfromtimestamp(ts) — deprecated in 3.12; returns naive datetime

• Python — datetime.fromtimestamp

Convertir la hora Unix en una fecha en PHP

gmdate(format, timestamp) en PHP devuelve una cadena de fecha en UTC para los segundos Unix dados; date(format, timestamp) devuelve el mismo instante en la zona horaria local del servidor (controlada por date_default_timezone_set o php.ini). La clase DateTime con DateTimeZone ofrece la API moderna e inmutable y admite cualquier nombre de zona IANA. PHP trabaja en segundos por defecto, así que divide primero los valores en milisegundos entre 1000.

• gmdate('c', 1700000000) // '2023-11-14T22:13:20+00:00' (UTC ISO 8601)
• date('Y-m-d H:i:s', 1700000000) // server-local — depends on date.timezone setting
• new DateTime('@1700000000') // immutable, UTC by default with the @ prefix
• (new DateTime('@1700000000'))->setTimezone(new DateTimeZone('Asia/Tokyo'))->format('c')
• DateTime::createFromFormat('U.u', '1700000000.123456') // sub-second precision

• PHP — referencia de gmdate()

Convertir la hora Unix en una fecha en Java

La API java.time de Java (Java 8+) convierte segundos Unix con Instant.ofEpochSecond(s), que devuelve un instante UTC — Instant siempre está en UTC, así que no hay sorpresa oculta con la zona local. Usa Instant.ofEpochMilli(ms) para entradas en milisegundos, adjunta una zona con atZone(ZoneId.of(...)) para una representación de reloj de pared, y formatea con DateTimeFormatter. El constructor heredado java.util.Date espera milisegundos, como JavaScript — multiplica primero los segundos por 1000L.

• Instant.ofEpochSecond(1700000000) // 2023-11-14T22:13:20Z (UTC)
• Instant.ofEpochMilli(1700000000000L) // from milliseconds
• Instant.ofEpochSecond(1700000000).atZone(ZoneId.of("Asia/Tokyo")) // tz-aware
• DateTimeFormatter.ISO_INSTANT.format(Instant.ofEpochSecond(s)) // ISO 8601
• new java.util.Date(1700000000L * 1000) // legacy API — expects milliseconds

• Timestamps Unix en Java — referencia completa

Convertir la hora Unix en una fecha en C# (.NET)

En .NET, DateTimeOffset.FromUnixTimeSeconds(s) es la conversión moderna — devuelve un DateTimeOffset anclado a UTC (+00:00). Usa FromUnixTimeMilliseconds(ms) para entradas en milisegundos. Lee .UtcDateTime para un DateTime en UTC, o convierte a una zona concreta con TimeZoneInfo.ConvertTime. Formatea con el especificador de ida y vuelta "o" para ISO 8601. Los métodos Unix integrados (añadidos en .NET 4.6) gestionan el cálculo de la epoch, así que evita el viejo patrón DateTime.AddSeconds-desde-1970.

• DateTimeOffset.FromUnixTimeSeconds(1700000000) // 2023-11-14 22:13:20 +00:00
• DateTimeOffset.FromUnixTimeMilliseconds(1700000000000) // from milliseconds
• DateTimeOffset.FromUnixTimeSeconds(s).UtcDateTime // DateTime in UTC
• TimeZoneInfo.ConvertTime(dto, tzInfo) // tz-aware rendering
• DateTimeOffset.FromUnixTimeSeconds(s).ToString("o") // ISO 8601 round-trip

• Timestamps Unix en C# — referencia completa

Convertir la hora Unix en una fecha en Go

time.Unix(sec, nsec) en Go construye un Time a partir de segundos Unix (más nanosegundos opcionales), pero devuelve el valor en la zona horaria local — llama a .UTC() para anclarlo. Go 1.17 añadió time.UnixMilli(ms) y time.UnixMicro(us), así que ya no divides a mano. Formatea con la constante RFC3339 para ISO 8601, y usa .In(loc) con time.LoadLocation para una zona concreta.

• time.Unix(1700000000, 0).UTC() // 2023-11-14 22:13:20 +0000 UTC
• time.UnixMilli(1700000000000).UTC() // from milliseconds (Go 1.17+)
• time.UnixMicro(1700000000000000).UTC() // from microseconds (Go 1.17+)
• time.Unix(1700000000, 0).Format(time.RFC3339) // ISO 8601 string
• time.Unix(s, 0).In(loc) // tz-aware; loc from time.LoadLocation

• Timestamps Unix en Go — referencia completa

Convertir la hora Unix en una fecha en el shell (Linux / macOS)

En Linux, el comando GNU date usa -d @ts para convertir desde segundos Unix; en macOS, el comando BSD date usa -r ts para la misma tarea. Los flags difieren según la implementación histórica — el cálculo de la epoch en sí es idéntico. El flag -u fuerza una salida en UTC independientemente de la variable de entorno TZ. Ambas implementaciones admiten formatos de salida arbitrarios mediante el argumento +%FORMAT; las cadenas de formato más útiles se resumen abajo.

• GNU (Linux): date -u -d @1700000000 // 'Tue Nov 14 22:13:20 UTC 2023'
• GNU: date -u -d @1700000000 +'%Y-%m-%dT%H:%M:%SZ' // ISO 8601 UTC
• BSD (macOS): date -u -r 1700000000 // same result, different flag
• BSD: date -u -r 1700000000 +'%Y-%m-%dT%H:%M:%SZ'
• Both: omit -u to use TZ environment variable; export TZ=America/New_York to override
• Sub-second: date -u -d @1700000000.123 +'%Y-%m-%dT%H:%M:%S.%3NZ' (GNU only)

• man date(1) — referencia del comando date de Linux

Convertir la hora Unix en una fecha en SQL (Postgres, MySQL, SQLite, BigQuery)

Cada gran dialecto SQL tiene una función integrada para convertir segundos Unix (o milisegundos, o microsegundos) en una columna timestamp nativa. Los nombres de función varían, pero la unidad que espera cada una está documentada y es coherente dentro de una base de datos. Usa la función dedicada en lugar de calcular el resultado a mano con aritmética de fechas — las funciones integradas manejan correctamente los años bisiestos, la precisión inferior al segundo y la conversión de zona horaria.

• PostgreSQL: TO_TIMESTAMP(1700000000) // returns TIMESTAMPTZ
• PostgreSQL: TO_TIMESTAMP(unix_us / 1000000.0) // for microsecond input
• MySQL: FROM_UNIXTIME(1700000000) // returns DATETIME in session timezone
• MySQL: CONVERT_TZ(FROM_UNIXTIME(ts), @@session.time_zone, 'UTC') // force UTC
• SQLite: datetime(1700000000, 'unixepoch') // returns TEXT 'YYYY-MM-DD HH:MM:SS'
• SQLite: datetime(ms / 1000, 'unixepoch') // from milliseconds
• BigQuery: TIMESTAMP_SECONDS(1700000000), TIMESTAMP_MILLIS(ms), TIMESTAMP_MICROS(us)
• ClickHouse: toDateTime(1700000000), fromUnixTimestamp(1700000000)

• PostgreSQL — funciones de formateo de tipos de datos
• Cómo almacenar timestamps Unix en una base de datos (guía complementaria)

Convertir la hora Unix en una fecha en Excel

Excel almacena las fechas como números de serie — el número de días desde el 1 de enero de 1900. Convertir un timestamp Unix en una fecha de Excel es solo conversión de unidad: divide los segundos Unix entre 86.400 (segundos por día) y suma la fecha del 1 de enero de 1970, luego formatea la celda como fecha. La fórmula =A1/86400 + DATE(1970,1,1) es la respuesta canónica y funciona en todas las versiones modernas de Excel. Para milisegundos, divide en su lugar entre 86.400.000. Tras introducir la fórmula, selecciona la celda, abre Formato de celdas (Ctrl+1) y elige un formato de fecha en la pestaña Número.

• Seconds: =A1/86400 + DATE(1970,1,1) // when A1 holds the Unix seconds value
• Milliseconds: =A1/86400000 + DATE(1970,1,1)
• Microseconds: =A1/86400000000 + DATE(1970,1,1)
• Format cell as Date after entering the formula (Ctrl+1 → Number → Date)
• Caveat: Excel's epoch is 1900-01-01, not 1970, hence the + DATE(1970,1,1) offset
• Reverse direction (date to Unix): =(A1 - DATE(1970,1,1)) * 86400

• Microsoft — función DATE

Convertir la hora Unix en una fecha en Google Sheets

Google Sheets acepta la misma fórmula canónica de Excel y además ofrece una función EPOCHTODATE dedicada. La forma corta es =EPOCHTODATE(A1, 1), donde el segundo argumento es el código de unidad: 1 para segundos, 2 para milisegundos, 3 para microsegundos. La salida es una fecha anclada a UTC que Sheets representa según la configuración regional de la hoja. Para hojas compartidas entre equipos en zonas distintas, documenta en el encabezado de columna qué zona se supone que representan las fechas.

• =EPOCHTODATE(A1, 1) // seconds — shorthand
• =EPOCHTODATE(A1, 2) // milliseconds
• =EPOCHTODATE(A1, 3) // microseconds
• =A1/86400 + DATE(1970,1,1) // canonical formula — works in Sheets too
• Reverse direction: =(A1 - DATE(1970,1,1)) * 86400
• Time zone applied is the sheet's locale; check File → Settings → Time zone

Fecha UTC vs fecha local — cuál mostrar

Un timestamp Unix codifica un instante, no una representación de reloj de pared. Dos visitantes en zonas distintas ven el mismo timestamp Unix como fechas de reloj diferentes. El comportamiento correcto depende de lo que represente la fecha: los registros de eventos y los registros de auditoría deberían mostrarse en UTC para una comparación entre regiones; las fechas orientadas al usuario (plazos, horarios de reunión, avisos de expiración) deberían mostrarse en la zona local del usuario. Elige siempre una y documéntala; nunca almacenes una cadena ya convertida a hora local sin almacenar también la zona de la que procede.

• Registros de servidor → mostrar en UTC, etiquetar explícitamente la columna o el eje del gráfico
• Plazos orientados al usuario → mostrar en la zona del usuario (autodetectar con Intl.DateTimeFormat().resolvedOptions().timeZone)
• Programaciones recurrentes ('cada lunes 9 AM Eastern') → almacenar la zona junto a la regla, recalcular el siguiente instante en cada disparo
• Respuestas de API → ISO 8601 con sufijo Z (UTC) es el valor por defecto seguro; deja que el cliente convierta
• Almacenamiento en base de datos → siempre UTC; convertir solo en la capa de presentación

• Base de datos de zonas horarias IANA (las reglas que usa cada runtime)
• ISO 8601 — el formato de fecha para la salida

Casos límite: precisión inferior al segundo, timestamps negativos y el año 2038

Tres casos límite hacen tropezar a código por lo demás correcto. Los timestamps en microsegundos (16 dígitos) necesitan un manejo explícito de la unidad; tratarlos como segundos da una fecha 1.000.000× demasiado lejos en el futuro. Los timestamps Unix negativos representan fechas anteriores a 1970 — la mayoría de los lenguajes los manejan, pero Excel, Google Sheets y algunas funciones SQL los limitan a 1970 o devuelven errores. El problema del año 2038 es el desbordamiento del entero con signo de 32 bits que ocurre el 19/01/2038 a las 03:14:07 UTC; los valores posteriores requieren almacenamiento BIGINT o time_t de 64 bits.

• Microsegundos (16 dígitos) — dividir entre 1.000.000 antes de pasar a las funciones de segundos del lenguaje
• Segundos negativos — fechas anteriores a 1970; JavaScript Date, Python datetime y PHP DateTime los manejan todos
• Segundos negativos en Excel — producen #### o una fecha errónea; usa la fórmula =A1/86400 + DATE(1970,1,1) solo para valores positivos
• Año 2038 — INT y time_t con signo de 32 bits se desbordan en 2147483647 = 2038-01-19 03:14:07 UTC
• Más allá de 2038 — almacenar como BIGINT (el 64 bits con signo cubre 292.000 millones de años a cada lado de la epoch)
• Antes de 1900 en Excel — la aplicación no sabe representarlo; convierte a texto o usa una biblioteca previa que admita fechas a.C.

• El problema del año 2038 (Y2K38) — guía completa

Errores frecuentes al convertir la hora Unix en una fecha

El mismo error aparece cada vez que alguien convierte la hora Unix en una fecha por primera vez: el resultado cae en 1970. La causa es casi siempre un × 1000 olvidado en JavaScript, o el argumento tz que falta en Python, o una columna numérica truncada automáticamente por Excel. El artículo complementario sobre errores cataloga los 10 — cada uno aparece en código que convierte la hora Unix en algún momento. Léelo una vez y la mayoría nunca llegarán a producción.

• La fecha muestra 1970 — pasaste segundos donde se esperaban milisegundos (constructor JS Date)
• La fecha está desfasada por tu offset UTC local — olvidaste especificar tz=timezone.utc (Python) o la opción timeZone (JS)
• Excel muestra ##### o un error #¡VALOR! — la celda no está formateada como Fecha, o el valor es negativo
• SQL FROM_UNIXTIME devuelve el reloj de pared incorrecto — MySQL aplica @@session.time_zone; fuerza UTC explícitamente
• Servidor vs portátil producen fechas distintas — zonas de sistema diferentes; pasa siempre tz explícitamente

• 10 errores frecuentes de timestamp Unix y cómo corregirlos (complementario)