Skip to content

Convertisseur Timestamp Unix

Convertissez les timestamps Unix en dates instantanément. Détection auto secondes, millisecondes, microsecondes. Horloge epoch en direct, conversion bidirectionnelle. Gratuit et privé.

Sans pistage Fonctionne dans le navigateur Gratuit
Tout le traitement s'effectue dans votre navigateur. Aucune donnée n'est envoyée à un serveur.

Timestamp Unix Actuel

0

Référence Rapide

Exemples de Code

Qu'est-ce qu'un Timestamp Unix (Epoch Time) ?

Un timestamp Unix (également appelé temps Unix, temps POSIX ou temps epoch) est un système permettant de décrire un instant précis sous la forme d'un entier unique — le nombre de secondes écoulées depuis l'époque Unix : le 1er janvier 1970 à 00:00:00 UTC (Temps Universel Coordonné). Cette représentation simple et compacte est le fondement du suivi du temps dans pratiquement chaque système d'exploitation, langage de programmation, base de données et API sur Internet.

L'époque Unix — le 1er janvier 1970 — n'a pas été choisie arbitrairement. Unix a été développé aux Bell Labs à la fin des années 1960, et 1970 était un point de départ rond et pratique, suffisamment récent pour que les dates courantes tiennent dans des entiers de taille raisonnable. Tout moment dans le temps peut être exprimé comme le compte d'entiers signés 64 bits de secondes depuis ce point d'ancrage. Les dates antérieures à l'époque sont représentées par des nombres négatifs : le 31 décembre 1969 à minuit UTC est -86400 (un jour, soit 86 400 secondes, avant l'époque).

Les systèmes modernes ont souvent besoin d'une résolution temporelle plus fine que les secondes entières. Pour y répondre, les timestamps sont couramment exprimés en millisecondes (millièmes de seconde, comme retourné par Date.now() de JavaScript) ou en microsecondes (millionièmes de seconde, utilisés dans des bases de données comme PostgreSQL). Vous pouvez identifier la précision par le nombre de chiffres : 10 chiffres indiquent des secondes, 13 des millisecondes, et 16 des microsecondes. Ce convertisseur détecte automatiquement la précision de votre entrée.

Cet outil convertit n'importe quel timestamp Unix — y compris le temps epoch actuel affiché dans l'horloge en direct ci-dessus — en date lisible instantanément.

// Get the current Unix timestamp in JavaScript
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // → 1741965432

// Milliseconds (native JavaScript)
const timestampMs = Date.now();
console.log(timestampMs); // → 1741965432000

// Convert timestamp back to a Date object
const date = new Date(timestampSeconds * 1000);
console.log(date.toISOString()); // → '2025-03-14T15:37:12.000Z'

// Python equivalent
// import time
// timestamp = int(time.time())  # → 1741965432

Fonctionnalités Clés

Détection Automatique de Précision

Détecte automatiquement si votre timestamp est en secondes (10 chiffres), millisecondes (13 chiffres) ou microsecondes (16 chiffres) — sans changement de mode manuel.

Conversion Bidirectionnelle

Convertissez les timestamps en dates lisibles, ou choisissez n'importe quelle date pour obtenir instantanément le timestamp Unix correspondant dans les trois formats de précision.

Horloge Epoch en Direct

Visualisez le timestamp Unix actuel qui s'incrémente en temps réel, pour toujours avoir un point de référence précis pour vos conversions et calculs.

Sortie Multi-Format

Chaque conversion affiche simultanément l'heure UTC, votre fuseau horaire local, le format ISO 8601 et un temps relatif convivial (ex. « il y a 3 jours »).

Traitement 100% Côté Navigateur

Toutes les conversions s'effectuent entièrement dans votre navigateur via l'API JavaScript Date. Aucun timestamp, date ou donnée personnelle n'est transmis à un serveur.

Timestamp Unix vs Autres Formats de Date

ISO 8601

2025-03-14T15:37:12Z

À la fois lisible par l'humain et triable lexicographiquement. Standard pour l'échange de données et les API. Préféré aux timestamps Unix quand la lisibilité humaine est importante.

RFC 2822

Ven, 14 Mar 2025 15:37:12 +0000

Lisible par l'humain mais non triable. Principalement utilisé dans les en-têtes d'email (champ Date). Moins compact qu'ISO 8601 et les timestamps Unix.

Date Lisible

14 mars 2025 15 h 37

Le format le plus lisible pour les utilisateurs finaux mais non triable et non adapté à un usage programmatique. À réserver aux couches d'affichage UI.

Exemples de Conversion

Timestamp Unix Standard (secondes)

1741965432
2025-03-14T15:37:12Z

Un timestamp de 10 chiffres en secondes — le format le plus courant utilisé par les systèmes Unix/Linux, les API Unix, les tokens JWT et les journaux de serveur. Cette valeur correspond au jour de Pi 2025 à 15:37:12 UTC.

Timestamp An 2000 — 1er Janvier 2000

946684800
2000-01-01T00:00:00Z

Le timestamp Unix pour l'an 2000 : exactement 946 684 800 secondes après l'époque Unix. C'est une valeur de calibration utile — si votre convertisseur affiche le 1er janvier 2000 pour cette entrée, il fonctionne correctement.

Timestamp Négatif (Avant l'Époque)

-86400
1969-12-31T00:00:00Z

Les timestamps Unix négatifs représentent des dates antérieures au 1er janvier 1970. La valeur -86400 est exactement un jour (86 400 secondes) avant l'époque, ce qui correspond au 31 décembre 1969 à minuit UTC.

Timestamp en Millisecondes (13 chiffres)

1741965432000
2025-03-14T15:37:12.000Z

Un timestamp de 13 chiffres en millisecondes — le format natif de Date.now() en JavaScript, System.currentTimeMillis() en Java et la plupart des API REST modernes. Le détecteur automatique reconnaît la longueur de 13 chiffres et l'analyse correctement en millisecondes.

Comment Convertir un Timestamp Unix en Date

  1. 1

    Choisir la Direction de Conversion

    Choisissez « Timestamp → Date » pour décoder un timestamp Unix en date lisible, ou « Date → Timestamp » pour convertir une date calendaire en timestamp Unix.

  2. 2

    Saisir Votre Valeur

    Collez ou tapez un timestamp Unix (ex. 1741965432 ou 1741965432000). L'outil identifie automatiquement s'il s'agit de secondes, millisecondes ou microsecondes. Pour Date → Timestamp, utilisez le sélecteur de date pour choisir l'année, le mois, le jour, l'heure, la minute et la seconde.

  3. 3

    Copier le Résultat Converti

    Consultez instantanément le résultat en UTC, heure locale, ISO 8601 et temps relatif. Cliquez sur le bouton Copier à côté de n'importe quel format pour le copier directement dans votre presse-papiers.

Cas d'Usage Courants

Développement et Débogage d'API
Décodez les timestamps opaques dans les réponses API, les payloads de tokens JWT (claims iat, exp, nbf), les données d'événements webhook et les entrées de journaux. Vérifiez instantanément si un token d'authentification est expiré ou quand un événement s'est produit.
Stockage et Requêtes de Timestamps en Base de Données
Convertissez entre timestamps Unix et dates lisibles lors de l'écriture de requêtes, de l'inspection d'enregistrements stockés ou de la validation des filtres de plage de dates dans vos clauses WHERE.
Analyse et Corrélation de Fichiers Journaux
De nombreux journaux système et applicatifs enregistrent les événements comme timestamps Unix. Convertissez les entrées suspectes en temps lisibles pour corréler les événements entre plusieurs services.
Vérification d'Expiration de Token JWT
Les JSON Web Tokens encodent iat (émis à), exp (expire à) et nbf (pas avant) comme timestamps Unix dans leur payload. Collez ces valeurs directement pour vérifier les fenêtres de validité des tokens.
Planification de Tâches Cron
Vérifiez que les planifications de tâches cron et les déclencheurs basés sur le temps s'alignent avec les fenêtres d'exécution prévues en convertissant les horaires proposés en timestamps.
Coordination de Dates Entre Fuseaux Horaires
Les timestamps Unix sont intrinsèquement neutres en timezone. Utilisez ce convertisseur pour établir un point de référence partagé lors de la coordination de dates entre équipes dans différents fuseaux horaires.

Référence Technique

Définition du Timestamp Unix
Un timestamp Unix est le nombre entier de secondes écoulées depuis l'époque Unix : le 1er janvier 1970 à 00:00:00 UTC. La valeur est identique quelle que soit la timezone locale de l'observateur, ce qui en fait une représentation idéale neutre en timezone pour stocker et comparer les temps.
Valeur Maximale d'un Entier Signé 32 Bits
La valeur maximale d'un entier signé 32 bits est 2 147 483 647. En tant que timestamp Unix, cela correspond au 19 janvier 2038 à 03:14:07 UTC. Les systèmes qui stockent les timestamps dans des entiers 32 bits signés déborderont à ce moment — un problème connu sous le nom de problème de l'an 2038.
JavaScript Utilise les Millisecondes
Date.now() et new Date().getTime() de JavaScript renvoient le nombre de millisecondes depuis l'époque, produisant des nombres de 13 chiffres. Pour convertir en timestamp Unix standard en secondes, divisez par 1000 et arrondissez : Math.floor(Date.now() / 1000).
Les Timestamps Négatifs Représentent les Dates Avant l'Époque
Les timestamps Unix peuvent être négatifs pour représenter des dates antérieures au 1er janvier 1970. Par exemple, -86400 représente le 31 décembre 1969 à 00:00:00 UTC. La plage d'un timestamp 64 bits signé s'étend sur environ 292 milliards d'années avant et après l'époque.
Le Temps Unix Ne Tient Pas Compte des Secondes Intercalaires
Le temps Unix suppose exactement 86 400 secondes par jour (24 × 60 × 60). En réalité, des secondes intercalaires sont occasionnellement insérées par l'IERS pour maintenir UTC synchronisé avec la rotation terrestre. Pour la grande majorité des applications logicielles, cet écart d'environ 27 secondes accumulées sur 50 ans est complètement négligeable.

Bonnes Pratiques de Gestion des Timestamps

Toujours Stocker les Timestamps en UTC
Stockez les timestamps en UTC (ou sous forme de timestamps Unix) et convertissez en heure locale uniquement au niveau de l'affichage. Mélanger les fuseaux horaires dans votre base de données est une source courante de bugs difficiles à reproduire, surtout lors des transitions d'heure d'été.
Utiliser la Précision Milliseconde pour les API Modernes
La plupart des API modernes, environnements JavaScript et bases de données utilisent les millisecondes (timestamps de 13 chiffres) plutôt que les secondes. Lors de l'intégration avec des systèmes externes, confirmez la précision attendue — passer un timestamp en millisecondes là où des secondes sont attendues produira des dates environ 11 000 ans dans le futur.
Attention au Problème de l'An 2038
Les systèmes qui stockent les timestamps Unix dans des entiers signés 32 bits déborderont le 19 janvier 2038 à 03:14:07 UTC. Auditez les systèmes legacy pour les champs de timestamp 32 bits et migrez vers des entiers 64 bits ou des chaînes ISO 8601.
Ne Jamais Compter sur les Horloges Côté Client pour la Sécurité
Les horloges des appareils clients peuvent être réglées sur n'importe quelle valeur. Pour la logique sensible à la sécurité comme la vérification d'expiration JWT ou les timeouts de session, validez toujours les timestamps côté serveur avec une source de temps fiable.
Utiliser ISO 8601 pour l'Échange Lisible par l'Humain
Quand vous avez besoin d'un format à la fois analysable par machine et lisible par l'humain — par exemple dans les fichiers journaux, fichiers de configuration ou réponses API — ISO 8601 (ex. 2025-03-14T15:37:12Z) est le meilleur choix. Il est triable lexicographiquement, non ambigu, et supporté par presque tous les parseurs modernes.

Questions Fréquemment Posées

Pourquoi le temps Unix commence-t-il le 1er janvier 1970 ?
La date de l'époque Unix du 1er janvier 1970 a été choisie par les développeurs d'Unix aux Bell Labs à la fin des années 1960 comme point de départ commode et arrondi, suffisamment récent pour que les dates courantes tiennent dans des entiers de taille raisonnable. À l'époque, les timestamps étaient stockés dans des entiers 32 bits, donc l'époque devait être suffisamment proche du présent. 1970 était simplement une année entière propre après le début du développement du système. Il n'y a pas de signification technique profonde au 1er janvier 1970 spécifiquement — c'était un pragmatisme d'ingénierie. D'autres systèmes ont choisi des époques différentes : le Mac classique utilisait le 1er janvier 1904 ; Windows NT utilise le 1er janvier 1601 ; le temps GPS commence au 6 janvier 1980. Ce qui a permis à l'époque Unix de perdurer, c'est qu'Unix est devenu le système d'exploitation dominant en informatique, et chaque langage de programmation, base de données et système d'exploitation majeur a finalement adopté le temps Unix comme standard universel pour représenter les timestamps lisibles par machine.
Qu'est-ce que le problème de l'an 2038 ?
Le problème de l'an 2038 (aussi appelé Y2K38 ou l'Epochalypse) est un problème informatique qui affectera les systèmes stockant les timestamps Unix sous forme d'entiers signés 32 bits. La valeur maximale d'un entier signé 32 bits est 2 147 483 647, ce qui correspond en tant que timestamp Unix au 19 janvier 2038 à 03:14:07 UTC. Une seconde plus tard, le compteur déborde et revient à la valeur négative la plus grande représentable, correspondant au 13 décembre 1901 — causant l'interprétation des dates futures comme étant dans le passé lointain. La solution est simple : migrer vers des entiers signés 64 bits pour le stockage des timestamps. Un timestamp 64 bits peut représenter des dates environ 292 milliards d'années avant et après l'époque. La plupart des systèmes d'exploitation, langages et bases de données modernes utilisent déjà des timestamps 64 bits en interne. Le risque réside dans le code legacy, les systèmes embarqués, les systèmes d'exploitation 32 bits encore en production, les métadonnées de système de fichiers et les colonnes de base de données définies comme INT plutôt que BIGINT. Les développeurs doivent auditer leurs systèmes maintenant. La migration de 32 bits à 64 bits doit se faire avant 2038, et en pratique, les systèmes avec des enregistrements long terme (hypothèques, actifs d'infrastructure, documents légaux) peuvent rencontrer ce problème bien plus tôt.
Quelle est la différence entre les timestamps en secondes, millisecondes et microsecondes ?
Les timestamps Unix existent en trois précisions courantes, distinguées par le nombre de chiffres : **Secondes (10 chiffres)** : Le format Unix timestamp le plus originel et courant. `1741965432` représente une seconde spécifique. Utilisé par : les appels système Unix/Linux (time()), la plupart des utilitaires Unix, les tokens JWT (claims iat, exp), les en-têtes HTTP (Last-Modified) et de nombreuses API REST. **Millisecondes (13 chiffres)** : Précision au millième de seconde. `1741965432000` est le même instant que ci-dessus, multiplié par 1 000. Utilisé par : Date.now() de JavaScript, System.currentTimeMillis() de Java, Node.js, la plupart des API JavaScript/TypeScript modernes. **Microsecondes (16 chiffres)** : Précision au millionième de seconde. Utilisé par : les types TIMESTAMP et TIMESTAMPTZ de PostgreSQL, les systèmes de trading haute fréquence. L'erreur la plus courante est de mélanger les précisions — passer un timestamp en millisecondes à une fonction qui attend des secondes produira des dates environ 11 574 ans dans le futur. Vérifiez toujours la documentation du système avec lequel vous travaillez.
Le temps Unix tient-il compte des secondes intercalaires ?
Non — le temps Unix ne tient pas compte des secondes intercalaires, et c'est l'une de ses limitations connues pour les applications de chronométrage de précision. Les secondes intercalaires sont occasionnellement insérées par l'IERS pour maintenir UTC synchronisé avec la rotation légèrement irrégulière de la Terre. À ce jour, 27 secondes intercalaires ont été insérées depuis leur introduction en 1972. Le temps Unix suppose un calendrier parfaitement régulier avec exactement 86 400 secondes par jour. Quand une seconde intercalaire est insérée, le monde réel a une seconde que le temps Unix ignore. Différents systèmes d'exploitation gèrent cela différemment — Linux « étale » traditionnellement la seconde intercalaire en ralentissant légèrement l'horloge. Pour l'immense majorité des applications logicielles, l'écart d'environ 27 secondes accumulées sur 50 ans est complètement hors de propos. La différence est imperceptible pour toute application orientée humain.
Les timestamps Unix peuvent-ils être négatifs ?
Oui, les timestamps Unix peuvent être négatifs, et les timestamps négatifs sont une façon légitime et bien définie de représenter les dates antérieures à l'époque Unix (1er janvier 1970, 00:00:00 UTC). Chaque seconde avant l'époque correspond à un décrément de 1 à partir de zéro. Par exemple, -1 représente le 31 décembre 1969 à 23:59:59 UTC ; -86400 représente le 31 décembre 1969 à 00:00:00 UTC (exactement un jour avant l'époque) ; et -2208988800 représente le 1er janvier 1900 à 00:00:00 UTC. La plupart des langages de programmation et systèmes d'exploitation modernes supportent les timestamps négatifs. Python, JavaScript et PostgreSQL gèrent tous correctement les dates antérieures à 1970. Pour les dates historiques (antérieures à 1970), il est souvent plus sûr de stocker la date sous forme de chaîne ISO 8601 ou d'utiliser un type de date natif à la base de données plutôt que de dépendre des timestamps Unix négatifs pour la portabilité. Ce convertisseur gère correctement les timestamps négatifs.
Comment obtenir le timestamp Unix actuel en JavaScript, Python ou d'autres langages ?
Obtenir le timestamp Unix actuel est simple dans tous les principaux langages de programmation : JavaScript : Math.floor(Date.now() / 1000) (secondes) ou Date.now() (millisecondes) Python : import time; int(time.time()) (secondes) Go : time.Now().Unix() (secondes) ou time.Now().UnixMilli() (millisecondes) Java : System.currentTimeMillis() / 1000L (secondes) ou Instant.now().getEpochSecond() PHP : time() (secondes) Ruby : Time.now.to_i (secondes) Bash : date +%s (secondes) La chose la plus importante à retenir est que JavaScript fonctionne nativement en millisecondes, tandis que pratiquement tous les autres langages utilisent par défaut les secondes. Soyez toujours explicite sur la précision que vous utilisez, et documentez-le dans vos contrats d'API pour éviter les bugs d'intégration.
Comment convertir un temps epoch en date lisible ?
Il existe trois méthodes rapides pour convertir un temps epoch (timestamp Unix) en date lisible : **1. Utiliser ce convertisseur en ligne (le plus rapide)** Collez votre timestamp epoch dans le champ ci-dessus. L'outil détecte automatiquement s'il est en secondes, millisecondes ou microsecondes et affiche instantanément le résultat en UTC, heure locale, ISO 8601 et temps relatif. Cliquez sur Copier pour récupérer n'importe quel format. **2. Utiliser du code** En JavaScript : `new Date(1741965432 * 1000).toISOString()` renvoie `'2025-03-14T15:37:12.000Z'`. En Python : `from datetime import datetime, UTC; datetime.fromtimestamp(1741965432, UTC)` renvoie le même résultat. Attention : JavaScript utilise des millisecondes tandis que Python utilise des secondes. **3. Utiliser la ligne de commande** Sur Linux : `date -d @1741965432`. Sur macOS : `date -r 1741965432`. Sur Windows PowerShell : `[DateTimeOffset]::FromUnixTimeSeconds(1741965432).DateTime`. Les trois méthodes produisent le même résultat. Le convertisseur en ligne ci-dessus est l'option la plus rapide quand vous avez juste besoin d'une réponse sans ouvrir un terminal.
Quel est le timestamp Unix actuel ?
Le timestamp Unix actuel est affiché dans l'horloge en direct en haut de cette page, mise à jour chaque seconde. Le timestamp Unix est simplement le nombre de secondes depuis le 1er janvier 1970 00:00:00 UTC, et il s'incrémente d'exactement 1 chaque seconde. Pour obtenir le timestamp actuel par programmation : - **JavaScript** : `Math.floor(Date.now() / 1000)` (secondes) ou `Date.now()` (millisecondes) - **Python** : `import time; int(time.time())` - **Bash** : `date +%s` En 2026, le timestamp Unix actuel est dans la plage de 1,77 milliard (10 chiffres). Il atteindra 2 milliards vers mai 2033, et la valeur maximale pour les systèmes 32 bits (2 147 483 647) sera atteinte le 19 janvier 2038 à 03:14:07 UTC — le fameux problème de l'an 2038. Ajoutez cette page à vos favoris pour toujours avoir le temps epoch actuel en un clic.

Outils connexes

Voir tous les outils →

Convertisseur de Base — Binaire, Hex, Décimal & Octal

Outils de conversion

Convertissez des nombres entre binaire, hexadécimal, décimal, octal et toute base personnalisée (2-36) instantanément. Gratuit, privé, sans inscription — tout se passe dans votre navigateur.

Décodeur et Encodeur Base64

Encodage et formatage

Décodez et encodez en Base64 en ligne gratuitement. Conversion en temps réel, support UTF-8 et émojis. 100 % privé — dans votre navigateur. Sans inscription.

Compresseur d'Images en Ligne Gratuit

Outils de conversion

Compressez vos images JPEG, PNG & WebP gratuitement dans le navigateur — aucun envoi serveur. Lots de 20 images, qualité réglable, comparaison avant/après. 100% privé, sans inscription.

Formateur et Validateur JSON

Encodage et formatage

Formatez, validez et embellissez vos JSON dans le navigateur. Outil gratuit avec validation syntaxique, detection d'erreurs, minification et copie. 100 % prive.

Convertisseur de Longueur — Mètres, Pieds, Pouces

Outils de conversion

1 pouce = 2,54 cm, 1 pied = 0,3048 m, 1 mile = 1,609 km. Convertissez entre 16 unités de longueur instantanément — métriques, impériales et astronomiques. Gratuit et privé.

Générateur de Hash MD5 en Ligne et Vérificateur de Checksum

Outils de sécurité

Générez des hashes MD5, SHA-256, SHA-1 et SHA-512 gratuitement — 100% dans votre navigateur, sans inscription. Hachez texte ou fichiers, vérifiez les checksums et comparez les hashes en un clic. Vos données restent privées.