Convertisseur de timestamp Unix

Qu’est-ce qu’un timestamp Unix ?

Un timestamp Unix, aussi appelé temps epoch ou temps POSIX, est le nombre de secondes écoulées depuis le 1er janvier 1970 à 00:00

UTC, sans compter les secondes intercalaires. Cette date est appelée l’époque Unix. Les timestamps Unix sont largement utilisés en informatique parce qu’ils offrent une façon simple et non ambiguë de représenter un instant précis, quel que soit le fuseau horaire.

Comment utiliser cet outil

Timestamp vers date :

1. Saisissez un timestamp Unix en secondes (10 chiffres) ou en millisecondes (13 chiffres)
2. L’outil détecte automatiquement si l’entrée est en secondes ou en millisecondes
3. Cliquez sur « Maintenant » pour remplir avec le timestamp actuel
4. Les résultats sont affichés dans plusieurs formats pour plus de commodité

Date vers timestamp :

1. Sélectionnez une date avec le sélecteur de date
2. Définissez éventuellement une heure précise
3. Le timestamp Unix correspondant est affiché en secondes et en millisecondes

Formats de sortie

• ISO 8601 — format standard international, par exemple 2024-01-15T10:30:00.000Z
• RFC 2822 — format courant des e-mails et en-têtes HTTP, par exemple Mon, 15 Jan 2024 10:30:00 GMT
• Heure locale — formatée selon les paramètres régionaux du navigateur
• UTC — représentation en temps universel coordonné

Secondes ou millisecondes

Les timestamps Unix peuvent être représentés dans deux unités courantes :

• Secondes (10 chiffres) — format Unix traditionnel utilisé par la plupart des outils en ligne de commande et langages côté serveur, par exemple 1700000000
• Millisecondes (13 chiffres) — utilisé par JavaScript (Date.now()), Java et de nombreuses API, par exemple 1700000000000

Ce convertisseur détecte automatiquement l’unité utilisée selon le nombre de chiffres de votre entrée.

Timestamps courants

Timestamp	Date
0	1er janvier 1970 00:00 UTC (époque Unix)
1000000000	9 septembre 2001 01:46 UTC
1700000000	14 novembre 2023 22:13 UTC
2000000000	18 mai 2033 03:33 UTC
2147483647	19 janvier 2038 03:14 UTC (problème Y2K38)

Cas d’utilisation

• Déboguer des réponses d’API qui retournent des timestamps
• Convertir les timestamps de fichiers journaux en dates lisibles
• Configurer des tâches planifiées (cron jobs) avec des timestamps précis
• Travailler avec des bases de données qui stockent les dates sous forme de timestamps Unix
• Comparer des dates entre différents fuseaux horaires sans ambiguïté

Timestamp Unix dans les langages de programmation

Voici des exemples pour obtenir le timestamp Unix actuel et convertir un timestamp en date dans des langages courants.

Python

import time
import datetime

# Obtenir le timestamp Unix actuel
timestamp = int(time.time())

# Convertir le timestamp en date
dt = datetime.datetime.fromtimestamp(timestamp)
print(dt)  # ex. 2026-03-20 12:00:00

JavaScript

// Obtenir le timestamp Unix actuel (secondes)
const timestamp = Math.floor(Date.now() / 1000);

// Convertir le timestamp en date
const date = new Date(timestamp * 1000);
console.log(date.toISOString());

PHP

// Obtenir le timestamp Unix actuel
$timestamp = time();

// Convertir le timestamp en date
echo date('Y-m-d H:i:s', $timestamp);

Java

import java.time.Instant;
import java.time.ZoneId;
import java.time.LocalDateTime;

// Obtenir le timestamp Unix actuel
long timestamp = System.currentTimeMillis() / 1000;

// Convertir le timestamp en date
LocalDateTime dt = Instant.ofEpochSecond(timestamp)
    .atZone(ZoneId.systemDefault())
    .toLocalDateTime();

SQL (MySQL)

-- Obtenir le timestamp Unix actuel
SELECT UNIX_TIMESTAMP();

-- Convertir le timestamp en date
SELECT FROM_UNIXTIME(1710936000);
-- Résultat : '2024-03-20 12:00:00'

Go

package main

import (
    "fmt"
    "time"
)

// Obtenir le timestamp Unix actuel
ts := time.Now().Unix()

// Convertir le timestamp en date
t := time.Unix(ts, 0)
fmt.Println(t.Format("2006-01-02 15:04:05"))

Bash

# Obtenir le timestamp Unix actuel
date +%s

# Convertir un timestamp en date (Linux)
date -d @1710936000

# Convertir un timestamp en date (macOS)
date -r 1710936000

Valeurs courantes de timestamp Unix

Tableau de référence rapide de timestamps Unix notables pour les développeurs :

Date	Timestamp Unix (secondes)
1er janvier 1970 (époque Unix)	0
1er janvier 2000 (Y2K)	946684800
9 septembre 2001 (1 milliard)	1000000000
1er janvier 2025	1735689600
1er janvier 2026	1767225600
1er janvier 2027	1798761600
20 novembre 2286 (10 milliards)	10000000000
19 janvier 2038 (débordement Y2K38)	2147483647

Le problème de l’an 2038 (Y2K38)

Le problème de l’an 2038, souvent appelé Y2K38, est une limite informatique causée par le stockage des timestamps Unix sous forme d’entiers signés sur 32 bits. Un entier signé sur 32 bits peut contenir au maximum 2 147 483 647, ce qui correspond au 19 janvier 2038 à 03:14

UTC. Une seconde après cet instant, l’entier déborde et revient à une valeur négative, qui serait interprétée comme une date en décembre 1901.

Ce problème ressemble au bug de l’an 2000 qui a touché des systèmes au passage au nouveau millénaire. Cependant, Y2K38 peut avoir un impact plus profond, car les timestamps Unix sont fortement intégrés aux systèmes d’exploitation, systèmes de fichiers, bases de données et protocoles réseau.

Les systèmes modernes ont largement atténué ce risque en adoptant des timestamps sur 64 bits. Un entier signé sur 64 bits peut représenter des dates jusqu’à environ 292 milliards d’années dans le futur, ce qui élimine pratiquement le risque de débordement. La plupart des noyaux Linux modernes, macOS et versions de Windows utilisent déjà le temps sur 64 bits en interne. En revanche, certains systèmes embarqués anciens, bases de données plus vieilles et formats de fichier peuvent encore être vulnérables.

Outils associés

• Calculateur de dates — Calculez la différence entre deux dates ou ajoutez/soustrayez des jours
• Convertisseur d’heure militaire — Convertissez entre l’heure standard et l’heure militaire sur 24 heures
• Calculateur de durée — Trouvez la durée totale entre une heure de début et une heure de fin