Heure Unix en date — convertir n'importe quelle epoch en date lisible

L'heure Unix en date en une ligne

Voici toute la tâche en un exemple : le timestamp Unix 1700000000 devient 2023-11-14T22:13:20Z — mardi 14 novembre 2023 à 22:13:20 UTC. Un timestamp Unix compte les secondes depuis le 1er janvier 1970 UTC ; le convertir consiste donc à décoder ce compte en UTC et à le formater dans le fuseau horaire voulu. La seule chose qui casse les conversions est l'unité : 10 chiffres sont des secondes, 13 des millisecondes, 16 des microsecondes. Le tableau ci-dessous est l'instruction prête à copier pour chaque langage et outil de ce guide.

• Ouvrir le convertisseur de timestamp Unix
• Dans l'autre sens — date en timestamp Unix

Ce que signifie convertir l'heure Unix en date

Un timestamp Unix est le nombre de secondes depuis le 1er janvier 1970 UTC. Pour le convertir en date, on le décode en UTC, puis on le formate dans n'importe quel fuseau horaire. C'est tout le problème en une phrase — le reste de ce guide n'est que la syntaxe dans chaque langage. Chaque langage de programmation moderne fournit une fonction intégrée qui prend une valeur epoch Unix et renvoie un objet date ; la seule chose à surveiller est de savoir si le langage attend des secondes (Python, PHP, Linux date), des millisecondes (JavaScript Date) ou des microsecondes (PostgreSQL, BigQuery).

La règle de conversion rapide

Comptez les chiffres de votre valeur. Un nombre à 10 chiffres est en secondes Unix. Un nombre à 13 chiffres est en millisecondes Unix. Un nombre à 16 chiffres est en microsecondes Unix. L'epoch Unix a commencé le 1er janvier 1970 — donc les valeurs à 10 chiffres aujourd'hui (en 2026) commencent par 17 ou 18 ; les millisecondes commencent par 175 ou 176 suivis de 10 chiffres ; les microsecondes commencent par 1758 ou 1759. Détectez l'unité avant de passer la valeur à une fonction de conversion, et votre sortie tombera le bon jour au lieu de 1970.

• 10 chiffres → secondes Unix (plage 2001 à 2286)
• 13 chiffres → millisecondes Unix (plage 2001 à 2286)
• 16 chiffres → microsecondes Unix (plage 2001 à 2286)
• Les nombres proches de 10^9 (1 000 000 000) sont des secondes d'avant 2001 — toujours de l'heure Unix valide
• Les entiers négatifs sont des dates d'avant 1970 — la plupart des langages les gèrent ; à vérifier
• Les nombres au-dessus de 2^31 dans des colonnes INT atteignent la limite de l'an 2038 — voir ci-dessous

• Millisecondes vs secondes — le guide complet des unités

Convertir l'heure Unix en date en JavaScript

Le constructeur Date de JavaScript attend des millisecondes, donc une valeur en secondes Unix doit d'abord être multipliée par 1000. Le résultat est un objet Date ; formatez-le avec toISOString() pour de l'ISO 8601 en UTC, ou avec Intl.DateTimeFormat pour une chaîne lisible tenant compte du fuseau horaire. Passez toujours une option timeZone explicite — sans elle, JavaScript utilise le fuseau horaire local de l'environnement, qui diffère entre les machines de développement et les serveurs de production.

• 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 — constructeur Date()
• Formatage de date correct selon le fuseau en JavaScript (guide associé)

Convertir l'heure Unix en date en Python

datetime.fromtimestamp(ts, tz=timezone.utc) est la conversion canonique en Python. L'argument tz est requis pour un résultat UTC ; sans lui, Python renvoie le timestamp dans le fuseau horaire local du système — une source fréquente de bugs de décalage horaire sur les serveurs. utcfromtimestamp() est obsolète depuis Python 3.12 car il renvoyait un datetime naïf facile à mal utiliser. Pour les millisecondes, divisez par 1000 ; pour les microsecondes, par 1 000 000 — Python accepte directement les fractions de seconde.

• 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 l'heure Unix en date en PHP

gmdate(format, timestamp) en PHP renvoie une chaîne de date UTC pour les secondes Unix données ; date(format, timestamp) renvoie le même instant dans le fuseau horaire local du serveur (contrôlé par date_default_timezone_set ou php.ini). La classe DateTime avec DateTimeZone offre l'API moderne et immuable et prend en charge n'importe quel nom de fuseau IANA. PHP travaille en secondes par défaut, donc divisez d'abord les valeurs en millisecondes par 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 — référence gmdate()

Convertir l'heure Unix en date en Java

L'API java.time de Java (Java 8+) convertit les secondes Unix avec Instant.ofEpochSecond(s), qui renvoie un instant UTC — Instant est toujours en UTC, il n'y a donc pas de surprise cachée liée au fuseau local. Utilisez Instant.ofEpochMilli(ms) pour une entrée en millisecondes, attachez un fuseau avec atZone(ZoneId.of(...)) pour un rendu en horloge murale, et formatez avec DateTimeFormatter. Le constructeur hérité java.util.Date attend des millisecondes, comme JavaScript — multipliez d'abord les secondes par 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 — référence complète

Convertir l'heure Unix en date en C# (.NET)

En .NET, DateTimeOffset.FromUnixTimeSeconds(s) est la conversion moderne — elle renvoie un DateTimeOffset ancré en UTC (+00:00). Utilisez FromUnixTimeMilliseconds(ms) pour une entrée en millisecondes. Lisez .UtcDateTime pour un DateTime en UTC, ou convertissez vers un fuseau précis avec TimeZoneInfo.ConvertTime. Formatez avec le spécificateur aller-retour "o" pour de l'ISO 8601. Les méthodes Unix intégrées (ajoutées dans .NET 4.6) gèrent le calcul de l'epoch, évitez donc l'ancien motif DateTime.AddSeconds-depuis-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# — référence complète

Convertir l'heure Unix en date en Go

time.Unix(sec, nsec) en Go construit un Time à partir de secondes Unix (plus des nanosecondes optionnelles), mais renvoie la valeur dans le fuseau horaire local — appelez .UTC() pour l'ancrer. Go 1.17 a ajouté time.UnixMilli(ms) et time.UnixMicro(us), vous n'avez donc plus à diviser à la main. Formatez avec la constante RFC3339 pour de l'ISO 8601, et utilisez .In(loc) avec time.LoadLocation pour un fuseau précis.

• 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 — référence complète

Convertir l'heure Unix en date dans le shell (Linux / macOS)

Sous Linux, la commande GNU date utilise -d @ts pour convertir depuis des secondes Unix ; sous macOS, la commande BSD date utilise -r ts pour la même tâche. Les options diffèrent selon l'implémentation historique — le calcul de l'epoch lui-même est identique. L'option -u force une sortie en UTC quelle que soit la variable d'environnement TZ. Les deux implémentations prennent en charge des formats de sortie arbitraires via l'argument +%FORMAT ; les chaînes de format les plus utiles sont résumées ci-dessous.

• 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) — référence de la commande date sous Linux

Convertir l'heure Unix en date en SQL (Postgres, MySQL, SQLite, BigQuery)

Chaque grand dialecte SQL a une fonction intégrée pour convertir des secondes Unix (ou des millisecondes, ou des microsecondes) en une colonne timestamp native. Les noms de fonction varient, mais l'unité attendue par chacune est documentée et cohérente au sein d'une base de données. Utilisez la fonction dédiée plutôt que de calculer le résultat à la main avec de l'arithmétique de dates — les fonctions intégrées gèrent correctement les années bissextiles, la précision infra-seconde et la conversion de fuseau horaire.

• 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 — fonctions de formatage des types de données
• Stocker des timestamps Unix dans une base de données (guide associé)

Convertir l'heure Unix en date dans Excel

Excel stocke les dates sous forme de numéros de série — le nombre de jours depuis le 1er janvier 1900. Convertir un timestamp Unix en date Excel n'est que de la conversion d'unité : divisez les secondes Unix par 86 400 (secondes par jour) et ajoutez la date du 1er janvier 1970, puis formatez la cellule en date. La formule =A1/86400 + DATE(1970,1,1) est la réponse canonique et fonctionne dans toutes les versions modernes d'Excel. Pour les millisecondes, divisez plutôt par 86 400 000. Après avoir saisi la formule, sélectionnez la cellule, ouvrez Format de cellule (Ctrl+1) et choisissez un format Date sous l'onglet Nombre.

• 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 — fonction DATE

Convertir l'heure Unix en date dans Google Sheets

Google Sheets accepte la même formule canonique d'Excel et fournit aussi une fonction EPOCHTODATE dédiée. La forme courte est =EPOCHTODATE(A1, 1), où le deuxième argument est le code d'unité : 1 pour les secondes, 2 pour les millisecondes, 3 pour les microsecondes. La sortie est une date ancrée en UTC que Sheets affiche selon les paramètres régionaux de la feuille. Pour les feuilles partagées entre des équipes dans des fuseaux différents, documentez dans l'en-tête de colonne quel fuseau les dates sont censées représenter.

• =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

Date UTC vs date locale — laquelle afficher

Un timestamp Unix encode un instant, pas un affichage d'horloge murale. Deux visiteurs dans des fuseaux différents voient le même timestamp Unix comme des dates d'horloge différentes. Le bon comportement dépend de ce que la date représente : les journaux d'événements et les enregistrements d'audit devraient s'afficher en UTC pour une comparaison inter-régions ; les dates destinées aux utilisateurs (échéances, horaires de réunion, avis d'expiration) devraient s'afficher dans le fuseau local de l'utilisateur. Choisissez-en toujours un et documentez-le ; ne stockez jamais une chaîne déjà convertie en heure locale sans aussi stocker le fuseau d'où elle vient.

• Journaux serveur → afficher en UTC, étiqueter explicitement la colonne ou l'axe du graphique
• Échéances destinées aux utilisateurs → afficher dans le fuseau de l'utilisateur (détection auto via Intl.DateTimeFormat().resolvedOptions().timeZone)
• Planifications récurrentes ('chaque lundi 9h Eastern') → stocker le fuseau avec la règle, recalculer le prochain instant à chaque déclenchement
• Réponses d'API → l'ISO 8601 avec suffixe Z (UTC) est le défaut sûr ; laissez le client convertir
• Stockage en base → toujours UTC ; convertir uniquement à la couche de présentation

• Base de données des fuseaux IANA (les règles utilisées par chaque runtime)
• ISO 8601 — le format de date à produire en sortie

Cas limites : précision infra-seconde, timestamps négatifs et l'an 2038

Trois cas limites font trébucher du code par ailleurs correct. Les timestamps en microsecondes (16 chiffres) nécessitent une gestion explicite de l'unité ; les traiter comme des secondes donne une date 1 000 000× trop loin dans le futur. Les timestamps Unix négatifs représentent des dates antérieures à 1970 — la plupart des langages les gèrent, mais Excel, Google Sheets et certaines fonctions SQL plafonnent à 1970 ou renvoient des erreurs. Le problème de l'an 2038 est le débordement de l'entier signé 32 bits qui survient le 19/01/2038 à 03:14:07 UTC ; les valeurs au-delà nécessitent un stockage BIGINT ou un time_t 64 bits.

• Microsecondes (16 chiffres) — diviser par 1 000 000 avant de passer aux fonctions secondes du langage
• Secondes négatives — dates d'avant 1970 ; JavaScript Date, Python datetime et PHP DateTime les gèrent toutes
• Secondes négatives dans Excel — produisent #### ou une date erronée ; n'utilisez la formule =A1/86400 + DATE(1970,1,1) que pour les valeurs positives
• An 2038 — INT et time_t signé 32 bits débordent à 2147483647 = 2038-01-19 03:14:07 UTC
• Au-delà de 2038 — stocker en BIGINT (le 64 bits signé couvre 292 milliards d'années de part et d'autre de l'epoch)
• Avant 1900 dans Excel — l'application ne sait pas l'afficher ; convertir en texte ou utiliser une bibliothèque amont gérant les dates av. J.-C.

• Le problème de l'an 2038 (Y2K38) — guide complet

Bugs fréquents lors de la conversion de l'heure Unix en date

Le même bug apparaît à chaque fois que quelqu'un convertit l'heure Unix en date pour la première fois : le résultat tombe en 1970. La cause est presque toujours un × 1000 oublié en JavaScript, ou l'argument tz manquant en Python, ou une colonne numérique automatiquement tronquée par Excel. L'article associé sur les bugs en catalogue les 10 — chacun apparaît dans du code qui convertit l'heure Unix à un moment donné. Parcourez-le une fois et la plupart n'atteindront jamais la production.

• La date affiche 1970 — vous avez passé des secondes là où des millisecondes étaient attendues (constructeur JS Date)
• La date est décalée de votre offset UTC local — vous avez oublié de spécifier tz=timezone.utc (Python) ou l'option timeZone (JS)
• Excel affiche ##### ou une erreur #VALEUR! — la cellule n'est pas formatée en Date, ou la valeur est négative
• SQL FROM_UNIXTIME renvoie la mauvaise horloge murale — MySQL applique @@session.time_zone ; forcez UTC explicitement
• Serveur vs portable produisent des dates différentes — fuseaux système différents ; passez toujours tz explicitement

• 10 bugs fréquents de timestamp Unix et comment les corriger (associé)