Convertisseur de Timestamp Unix
Transformez un timestamp Unix (epoch) en une date lisible — dans votre heure locale, en UTC et en ISO 8601 — ou reconvertissez n'importe quelle date en timestamp. Fonctionne en secondes ou en millisecondes.
—
Millisecondes: —
ISO 8601: —
Collez une valeur epoch. Utilisez le sélecteur si votre timestamp est en millisecondes.
Choisissez une date et une heure pour obtenir son timestamp Unix.
Comment utiliser Convertisseur de Timestamp Unix
- 1
Saisissez un timestamp
Collez ou saisissez un timestamp Unix dans le champ « Timestamp en date », puis réglez le sélecteur Secondes / Millisecondes pour qu'il corresponde à votre valeur.
- 2
Lisez la date
Visualisez l'instant dans votre fuseau horaire local, en UTC, sous forme de chaîne ISO 8601 et en temps relatif, par exemple « il y a 3 heures ».
- 3
Reconvertissez une date
Utilisez le sélecteur « Date en timestamp » pour choisir n'importe quelle date et heure et obtenir sa valeur epoch en secondes et en millisecondes.
- 4
Copiez le résultat
Cliquez sur copier pour n'importe quelle valeur afin de la placer dans votre presse-papiers, prête à être collée dans du code, une requête de base de données ou un appel d'API.
Le temps Unix, expliqué aux développeurs
Ce qu'est un timestamp Unix
Un timestamp Unix est un nombre unique qui représente un instant précis : le décompte des secondes écoulées depuis l'epoch Unix, c'est-à-dire minuit UTC le 1er janvier 1970. Le timestamp 1700000000, par exemple, correspond au 14 novembre 2023 à 22:13:20 UTC. Un seul nombre capture la date et l'heure complètes, sans la moindre ambiguïté.
Parce qu'il s'agit simplement d'un entier qui ne fait que croître, le temps Unix est extrêmement facile à stocker, à trier et à comparer. Soustrayez un timestamp d'un autre et vous obtenez le nombre exact de secondes séparant deux événements. C'est cette simplicité qui lui vaut de sous-tendre une grande partie de l'informatique, des dates de modification de fichiers aux jetons d'authentification.
Pourquoi 1970
L'epoch de 1970 est un héritage historique du système d'exploitation Unix, alors en cours de développement aux Bell Labs à cette époque. Les ingénieurs avaient besoin d'un point de référence fixe pour l'horloge système, et le début de la décennie durant laquelle ils travaillaient constituait un choix net et pratique. Il s'est imposé, et des décennies plus tard, il demeure la norme sur la quasi-totalité des plateformes.
1970 n'a rien de mathématiquement particulier ; ce n'est qu'un point zéro commun. Ce qui compte, c'est que tout le monde s'accorde dessus. C'est cette référence commune qui permet qu'un timestamp généré sur une machine soit correctement interprété par n'importe quelle autre, quels que soient le fournisseur, le langage ou le lieu.
Secondes et millisecondes
Le temps Unix traditionnel se mesure en secondes, mais de nombreux environnements modernes utilisent les millisecondes pour une résolution plus fine. Date.now en JavaScript, par exemple, renvoie des millisecondes. L'indice pratique est le nombre de chiffres : un timestamp actuel en secondes compte 10 chiffres, tandis que le même instant en millisecondes en compte 13, soit environ mille fois plus.
Confondre les deux unités est un bug fréquent. Passez une valeur en millisecondes à une fonction qui attend des secondes et votre date se retrouve des dizaines de milliers d'années dans le futur ; faites l'inverse et vous revenez aux alentours de 1970. Si une date convertie paraît absurde, vérifiez d'abord l'unité. Le sélecteur Secondes / Millisecondes de cet outil existe précisément pour lever cette confusion en un clic.
UTC et heure locale
Un timestamp Unix ne porte en lui-même aucun fuseau horaire. Il marque le même instant partout sur Terre ; le nombre est identique que vous soyez à Tokyo ou à New York. Les fuseaux horaires n'entrent en jeu que lorsque vous convertissez cet instant en une date lisible, ce qui explique pourquoi un même timestamp s'affiche sous des heures différentes selon les endroits.
Ce convertisseur affiche les deux formes : votre heure locale, formatée selon le fuseau horaire de votre appareil, et l'UTC, la référence universelle. Stocker et transmettre les timestamps en UTC, puis ne les convertir en heure locale que pour l'affichage, est la pratique standard qui évite toute une catégorie de bugs de décalage horaire, en particulier autour des changements d'heure saisonniers (passage à l'heure d'été ou d'hiver).
Le problème de l'an 2038
De nombreux systèmes anciens stockent le temps Unix dans un entier signé de 32 bits, dont la valeur maximale est de 2 147 483 647. Ce plafond est atteint le 19 janvier 2038 à 03:14:07 UTC. Une seconde plus tard, le compteur déborde et bascule vers un grand nombre négatif, que ces systèmes interprètent comme une date remontant à 1901.
C'est l'écho moderne du bug de l'an 2000, et il menace les appareils embarqués, les bases de données héritées et tout code utilisant encore le temps sur 32 bits. La solution consiste à stocker le temps dans un entier plus large de 64 bits, ce qui repousse la limite à des centaines de milliards d'années. Cet outil, lui, s'exécute dans votre navigateur grâce à la gestion des dates intégrée à JavaScript plutôt qu'au temps sur 32 bits : il convertit donc sans problème des dates bien au-delà de 2038.
Convertir dans les deux sens
Passer d'un timestamp à une date revient à traiter le nombre comme un total de secondes depuis l'epoch et à les ajouter à celui-ci. L'opération inverse, transformer une date en timestamp, calcule combien de secondes séparent l'epoch de cet instant. Le convertisseur fait les deux : collez une valeur epoch pour lire sa date, ou choisissez une date dans le sélecteur pour obtenir son timestamp.
L'affichage en temps relatif, comme « il y a 3 heures », est obtenu en soustrayant le timestamp du moment présent et en décrivant l'écart en langage courant. C'est pratique pour vérifier une valeur d'un coup d'œil, car une entrée de journal censée provenir de deux ans dans le futur est manifestement suspecte.
Où vous rencontrerez le temps Unix
Les timestamps Unix sont partout dans les logiciels. Les journaux serveur en apposent un sur chaque ligne afin que les événements puissent être ordonnés avec précision. Les API REST les renvoient dans des champs comme created_at et expires_at parce qu'ils sont indépendants du langage et compacts. Les bases de données s'en servent pour le tri et pour les requêtes par fenêtre temporelle, et les JWT encodent l'expiration sous forme de timestamp Unix.
Pour les développeurs et les analystes, lire rapidement ces valeurs est un besoin quotidien. Lorsque vous déboguez une réponse d'API, parcourez un fichier journal ou vérifiez l'expiration d'un jeton, glisser le nombre brut dans un convertisseur transforme un entier opaque en une date que vous pouvez interpréter, à la fois dans votre heure locale et en UTC, en secondes ou en millisecondes.
Questions fréquentes
Qu'est-ce qu'un timestamp Unix ?
Mon timestamp est-il en secondes ou en millisecondes ?
Quel fuseau horaire le convertisseur utilise-t-il ?
Qu'est-ce que le problème de l'an 2038 ?
Mes données sont-elles envoyées à un serveur ?
Outils similaires
Continuez avec ces outils pratiques