Epoch Converter : timestamp Unix en date

Collez un timestamp ou une date : vous l'obtenez en toutes lettres, dans votre fuseau et en UTC, avec toutes les autres lectures possibles.

s · ms · µs · ns · FILETIME · .NET · Excel · NTP · GPS · fonctionne dans votre navigateur

Exemple · 817876800

samedi

2 décembre 1995

04:00:00 UTC

UTC
sam. 2 déc. 1995 · 04:00:00
sam. 2 déc. 1995 · 04:00:00UTC · UTC+00:00
Relatif
il y a 31 ans
Écrit en
ISO 8601 · UTC
1995-12-02T04:00:00Z
ISO 8601 · UTC
1995-12-02T04:00:00Z
RFC 5322 · e-maille format défini par la RFC 2822
Sat, 02 Dec 1995 04:00:00 +0000
Date HTTPRFC 9110
Sat, 02 Dec 1995 04:00:00 GMT
SQL DATETIMEUTC
1995-12-02 04:00:00
Secondes
817876800
Millisecondes
817876800000
Microsecondes
817876800000000
Nanosecondes
817876800000000000

Un nombre · tous les epochs

7 lectures tombent sur une date réelle

Lecture : Secondes Unix, d'après sa longueur (9 chiffres). Avec la lecture Secondes GPS, ce serait le 6 décembre 2005 : une date réelle aussi, elle reste donc à un clic.

LectureTombe le
1900–2100 : une date réelleAujourd'hui2038 : la limite des 32 bitsNe tombe sur aucune date réelleChoisissez une lecture pour l'utiliser
Maintenant

Millisecondes
Microsecondes
Nanosecondes
ISO 8601

L'horloge de votre navigateur compte en millisecondes entières : les zéros qui suivent sont du remplissage, pas de la précision.

Date et heure → timestamp
Fuseau horaire

UTC · UTC+00:00 à cette date

1793813880
Millisecondes
1793813880000
ISO 8601
2026-11-04T17:38:00Z
Début et fin, fuseau UTC
DébutFin
Jour17937504001793836799
Mois17934912001796083199
Année17672256001798761599

Tout se passe dans cet onglet : rien de ce que vous collez n'est envoyé nulle part.

Comment utiliser le convertisseur de timestamp (Epoch Converter)

Collez votre timestamp dans le champ, quelle que soit son unité, et la date s'affiche dans votre fuseau horaire et en UTC. Vous pouvez aussi saisir une date, l'en-tête Date d'un e-mail ou le mot maintenant pour obtenir son temps epoch.

La page lit un nombre à la fois en secondes, millisecondes, microsecondes et nanosecondes, choisit la lecture qui tombe sur une date réelle, dit pourquoi et garde les autres lectures à un clic. Sous la réponse, les mêmes chiffres sont lus comme un timestamp Windows, .NET, Mac, Excel, NTP et GPS, et chaque format peut être copié.

Epoch Converter lisant 133756272000000000 comme un Windows FILETIME : 9 novembre 2024, chaque epoch sur une friseEpoch Converter lisant 133756272000000000 comme un Windows FILETIME : 9 novembre 2024, chaque epoch sur une friseCollez n'importe quoiUn nombre dans n'importe quelle unité, une date ISO, l'en-tête Date d'un e-mail, un datetime SQL ou le mot maintenant. L'étiquette indique comment il a été lu.Les chiffres, comptésLa règle sous le nombre groupe ses chiffres par trois : 18 chiffres se lisent ainsi en six groupes, premier indice de ce qu'est ce nombre.La réponse d'abordLe jour de la semaine et la date en toutes lettres, puis l'heure en UTC et dans votre propre fuseau, et chaque format à copier.Quelle lecture, et pourquoiLa page dit en toutes lettres quelle lecture elle a choisie et pourquoi, et nomme l'autre lecture qui tombe aussi sur une date réelle.Tous les autres epochsLes mêmes chiffres lus dans chaque unité et chaque epoch, chacun en barre depuis son propre début. Choisissez une ligne pour utiliser cette lecture.
L'outil lisant un Windows FILETIME. Choisissez un numéro pour voir le rôle de chaque partie.

Qu'est-ce que le temps epoch (l'epoch Unix) et pourquoi commence-t-il en 1970 ?

Le temps epoch, ou temps Unix, est le nombre de secondes écoulées depuis 1970-01-01 00:00:00 UTC, l'instant que POSIX appelle l'Epoch. Le timestamp 0 est cet instant, et 817876800 correspond à 1995-12-02 04:00 UTC.

Aucune source primaire n'indique pourquoi 1970 a été choisi. Le premier manuel d'Unix, en novembre 1971, comptait des soixantièmes de seconde depuis le 1er janvier 1971 et notait que son horloge serait épuisée dans deux ans et demi environ ; à la septième édition, en 1979, le compte était en secondes depuis le 1er janvier 1970, une date ronde proche de l'époque où Unix était écrit. UTC n'est apparu qu'en 1972 : les timestamps antérieurs sont donc en UTC par convention.

Unix, première édition, 1971soixantièmes de seconde depuis le 1 janvier 1971, sur 32 bits

saturé le 8 avril 1973 · 2,27 ans

Unix, septième édition, 1979secondes depuis le 1 janvier 1970, dans un nombre signé de 32 bits

1901-12-13 → 2038-01-1968 ans dans chaque sens

valeurs négatives : avant 1970

L'utilisateur à l'esprit--chronologique remarquera que 2**32 soixantièmes de seconde ne font qu'environ 2,5 ans.

UNIX Programmer's Manual, première édition, time (II), 3 novembre 1971

Tous les epochs que lit cette page, sur une même ligne

  1. .NET0001-01-01 · ticks de 100 ns
  2. Windows FILETIME1601-01-01 · ticks de 100 ns
  3. Excel1899-12-30 · jours
  4. NTP1900-01-01 · secondes
  5. Mac HFS+1904-01-01 · secondes
  6. Excel 19041904-01-01 · jours
  7. Unix1970-01-01 · secondes
  8. GPS1980-01-06 · secondes
Les deux barres sont calculées d'après la taille du compteur : 2³² soixantièmes de seconde remplissent 2,27 ans, un peu moins que l'estimation du manuel lui-même. Chaque autre epoch que lit cette page commence ailleurs sur la même ligne, tracée sur l'axe du temps du convertisseur lui-même. Source : time (II), 1971, time (2), 1979

Mon timestamp est-il en secondes, millisecondes, microsecondes ou nanosecondes ?

Comptez les chiffres : un timestamp actuel compte 10 chiffres en secondes, 13 en millisecondes, 16 en microsecondes et 19 en nanosecondes. JavaScript et Java utilisent les millisecondes ; les outils Unix et la plupart des API, les secondes.

Le nombre de chiffres est un indice fort, pas une preuve. Les timestamps NTP, GPS et Mac ont aussi dix chiffres aujourd'hui, et un Windows FILETIME comme un nombre de ticks .NET en ont dix-huit : c'est pourquoi cette page lit toutes les échelles à la fois et affiche la lecture choisie à côté des autres. Un FILETIME dépasse aussi ce que JavaScript peut contenir exactement, donc la page garde les chiffres tels que vous les avez collés.

10 chiffres · 4 échelles · les chiffres seuls ne disent pas laquelle

Secondes Unix1792972800
Secondes NTP4001961600
Secondes GPS1477008018
Mac HFS+3875817600
Millisecondes Unix1792972800000
Microsecondes Unix1792972800000000

18 chiffres · 2 échelles · seul le premier chiffre les distingue

Windows FILETIME134374464000000000
Ticks .NET639285696000000000
Nanosecondes Unix1792972800000000000

Les secondes à 10 chiffres vont de 2001-09-09T01:46:40Z à 2286-11-20T17:46:39Z. Soit une durée de 285 ans, pas une unité.

Chaque valeur est le même instant, 26 octobre 2026, 00:00 UTC, sur sa propre échelle. La longueur distingue les unités Unix ; elle ne distingue pas les epochs. Source : ECMA-262 §21.4.1, [MS-DTYP] 2.3.3, DateTime.Ticks

Comment convertir un timestamp Unix en date dans mon fuseau horaire ?

Un timestamp Unix n'a pas de fuseau horaire : il désigne le même instant partout. La date dépend de l'endroit où vous le lisez, donc la page affiche votre propre fuseau et UTC côte à côte, ainsi que tout autre fuseau que vous choisissez.

Le sélecteur de fuseau utilise la base de fuseaux horaires IANA, la même que votre système d'exploitation : les changements d'heure sont appliqués pour la date elle-même, pas pour aujourd'hui. Dans l'autre sens, une date saisie sans décalage est lue en UTC, et la page propose de la lire plutôt dans votre propre fuseau.

Un instant1793057400= 2026-10-26T23:30:00Z

  • Los Angeles16:30lun. 26 oct.UTC−07:00
  • New York19:30lun. 26 oct.UTC−04:00
  • UTC23:30lun. 26 oct.UTC+00:00
  • Berlin00:30mar. 27 oct.UTC+01:00
  • Calcutta05:00mar. 27 oct.UTC+05:30
  • Tokyo08:30mar. 27 oct.UTC+09:00
  • Lord Howe10:30mar. 27 oct.UTC+11:00

Berlin, 29 mars 202623 heures · les horloges sont passées de 02:00 à 03:00

Berlin, 25 octobre 202625 heures · les horloges ont reculé de 03:00 à 02:00

heure normale d’Europe centrale · UTC+01:00heure d’été d’Europe centrale · UTC+02:00l'heure vécue deux foisl'heure qui n'a jamais existé

Un timestamp, 7 horloges locales : là où la date locale n'est pas celle d'UTC, elle est signalée. Lors des deux jours de changement d'heure de Berlin en 2026, une heure n'a désigné aucun instant et une autre en a désigné deux. Source : ECMA-262 §21.4.1.19, IANA tz

Que se passe-t-il pour le temps Unix en 2038 ?

Un temps Unix stocké dans un entier signé de 32 bits s'arrête à 2147483647, soit 2038-01-19 03:14:07 UTC ; une seconde plus tard, il revient à une date de décembre 1901. Les systèmes qui comptent sur 64 bits, comme l'exige désormais POSIX, ne sont pas concernés.

En 2026, le risque est dans le stockage, pas dans les horloges : une colonne TIMESTAMP de MySQL s'arrête toujours à 2038-01-19 03:14:07 UTC, tout comme les formats de fichiers et les appareils embarqués qui ont gardé un champ de 32 bits. NTP a son propre débordement, plus tôt : ses secondes sur 32 bits reviennent à zéro en 2036. La page signale tout timestamp proche de la limite de 2038 ou au-delà.

2 147 483 647le plus grand nombre signé de 32 bits

01111111 11111111 11111111 11111111

mar. 19 janv. 203803:14:07 UTC

+ 1 seconde

-2 147 483 648les mêmes 32 bits, lus comme un nombre signé

10000000 00000000 00000000 00000000

ven. 13 déc. 190120:45:52 UTC

Dernière seconde, UTC

time_t signé de 32 bits2038-01-19 03:14:07
Secondes non signées sur 32 bits2106-02-07 06:28:15
Colonne TIMESTAMP de MySQL2038-01-19 03:14:07
NTP, ère 02036-02-07 06:28:15
Dates Mac HFS+2040-02-06 06:28:15

aujourd'hui2038-01-19

Chaque fin est calculée d'après la taille du champ : la dernière seconde entière qu'il peut contenir. Un time_t de 64 bits, qu'exige POSIX.1-2024, couvre environ 292 milliards d'années de part et d'autre de 1970. Source : POSIX.1-2024 A.4.19, MySQL 8.4, RFC 5905 §6, TN1150

Un timestamp Unix peut-il être négatif ?

Oui : un timestamp négatif est une date antérieure à 1970. -1 correspond à 1969-12-31 23:59:59 UTC, et -86400 à 1969-12-31 00:00:00 UTC.

POSIX lui-même laisse les valeurs négatives indéfinies, mais GNU et la plupart des systèmes les traitent comme des dates antérieures à 1970 par une extension documentée, tout comme JavaScript, Python et PostgreSQL. MySQL est l'exception : sa colonne TIMESTAMP commence en 1970, et FROM_UNIXTIME(-1) renvoie NULL. Les dates de naissance et les archives historiques sont des timestamps négatifs ordinaires : la page les lit donc comme des dates au lieu d'y voir une erreur.

SecondesJusqu'où en arrière (échelle log.)Date, UTC

0jeu. 1 janv. 197000:00:00 UTC
-1mer. 31 déc. 196923:59:59 UTC
-86 400mer. 31 déc. 196900:00:00 UTC
-31 536 000mer. 1 janv. 196900:00:00 UTC
-1 000 000 000dim. 24 avr. 193822:13:20 UTC
-2 147 483 648ven. 13 déc. 190120:45:52 UTC
  • POSIXSi l'année est <1970 ou si la valeur est négative, la relation n'est pas définie.
  • GNU date@-1 vaut 1969-12-31 23:59:59 UTC : des valeurs négatives, en extension de POSIX
  • JavaScripttoute date jusqu'à environ 273 790 ans avant ou après 1970
  • MySQL TIMESTAMPcommence à 1970-01-01 00:00:01 UTC : ne peut pas contenir de valeur négative
Chaque valeur est lue en secondes Unix. Les barres sont sur une échelle logarithmique, pour que les petites valeurs restent visibles. La dernière ligne est le plus petit nombre que contient un champ signé de 32 bits : l'autre extrémité du problème de 2038. Source : POSIX.1-2024 §4.19, GNU Coreutils, ECMA-262 §21.4.1, MySQL 8.4

Windows, .NET, Mac, Excel, NTP et GPS : les autres epochs

Beaucoup de systèmes comptent depuis leur propre zéro : Windows depuis 1601, .NET depuis l'an 1, Mac et HFS+ depuis 1904, Excel depuis 1900, NTP depuis 1900 et GPS depuis le 6 janvier 1980. Un nombre qui n'a pas de sens comme timestamp Unix est souvent l'un d'eux.

Le FILETIME 133756272000000000, par exemple, compte des intervalles de 100 nanosecondes depuis 1601 et correspond à 2024-11-09 12:00:00 UTC. Excel compte des jours et traite 1900 comme une année bissextile à dessein : ses numéros de série inférieurs à 61 sont donc décalés d'un jour, et la page les signale. Le temps GPS ignore les secondes intercalaires et a 18 secondes d'avance sur UTC depuis 2017.

EpochCompteDepuisLe 26 oct. 2026ChiffresFuseau horaireOù on le rencontre
Secondes Unixsecondes1970-01-01179297280010UTC (POSIX)date +%s, time.time() en Python
Millisecondes Unixmillisecondes1970-01-01179297280000013UTCDate.now() en JavaScript, Java
Nanosecondes Unixnanosecondes1970-01-01179297280000000000019UTCUnixNano() en Go
Windows FILETIMEticks de 100 ns1601-01-0113437446400000000018UTC (heure locale sur FAT)NTFS, lastLogon d'Active Directory, Win32
Ticks .NETticks de 100 ns0001-01-0163928569600000000018UTC ou locale, selon KindDateTime.Ticks
N° de série Exceljours1899-12-30463215aucun : date et heure sans fuseauExcel, Google Sheets, LibreOffice
Excel 1904jours1904-01-01448595aucun : date et heure sans fuseauanciennes versions d'Excel pour Mac
Mac HFS+secondes1904-01-01387581760010GMT (HFS classique : locale)dates des fichiers HFS+
Secondes NTPsecondes1900-01-01400196160010UTCpaquets NTP
Secondes GPSsecondes1980-01-06147700801810sans secondes intercalaires : UTC + 18srécepteurs GPS, fichiers RINEX
Chaque valeur est le même instant, 26 octobre 2026, 00:00 UTC, sur sa propre échelle, calculée par le moteur qui fait tourner cette page. Google Sheets et LibreOffice comptent aussi les jours depuis 1899-12-30 : à partir du 1 mars 1900, leurs numéros de série concordent donc avec ceux d'Excel. Source : [MS-DTYP] 2.3.3, DateTime.Ticks, Excel, Google Sheets, LibreOffice, TN1150, RFC 5905, RINEX 3.05

Le temps Unix compte-t-il les secondes intercalaires ?

Non. Le temps Unix donne à chaque jour exactement 86 400 secondes, donc une seconde intercalaire n'a pas de nombre propre, et POSIX le dit lui-même : le temps POSIX décomposé n'est pas nécessairement de l'UTC, malgré les apparences.

Depuis 1972, 27 secondes intercalaires ont été ajoutées à UTC ; le temps Unix n'a pas de nombre pour la seconde supplémentaire, donc un même timestamp désigne deux secondes. La dernière date du 2016-12-31, et en 2022 la Conférence générale des poids et mesures a décidé que d'ici 2035 la limite qui les rend nécessaires serait relevée, ce qui y met fin en pratique. Le temps GPS, qui n'en a jamais eu, montre la différence : il a 18 secondes d'avance.

Les dernières secondes du 31 décembre 1998

UTC23:59:5823:59:5923:59:6000:00:0000:00:01
Temps Unix915148798915148799915148800915148800915148801
Temps GPS599184010599184011599184012599184013599184014

Le temps Unix donne 915148800 deux fois ; le temps GPS, qui n'a pas de secondes intercalaires, continue de compter.

27 secondes intercalairesaucune après le 31 décembre 2016 · aucune annoncée avant le 28 juin 2027

avant le début du temps GPSdepuis le début du temps GPS : chacune l'a fait avancer d'une seconde de plus

Le temps universel coordonné (UTC) inclut les secondes intercalaires. Cependant, dans le temps POSIX (secondes écoulées depuis l'Epoch), les secondes intercalaires sont ignorées (non appliquées) afin de fournir une méthode simple et compatible de calcul des différences de temps. Le temps POSIX décomposé n'est donc pas nécessairement de l'UTC, malgré les apparences.

POSIX.1-2024, Rationale A.4.19
Juste après cette seconde intercalaire, le temps GPS avait 13 secondes d'avance sur UTC. Source : POSIX.1-2024 A.4.19, leap-seconds.list, RINEX 3.05

Les timestamps Unix en Python, JavaScript, Java, C#, Go, SQL et dans le shell

Chaque langage convertit dans les deux sens en une ou deux lignes. Les pièges sont l'unité (JavaScript et Java comptent en millisecondes) et le fuseau horaire (une base de données peut lire la valeur dans le fuseau de sa session).

Chaque exemple ci-dessous transforme 817876800 en date et une date en secondes, et chacun a été exécuté pour vérifier sa sortie. Dans le shell, macOS et les BSD prennent date -r 817876800, alors que GNU/Linux prend date -d @817876800 : les deux ne sont pas interchangeables.

from datetime import datetime, timezone

t = datetime.fromtimestamp(817876800, tz=timezone.utc)
print(t.isoformat())  # 1995-12-02T04:00:00+00:00

back = datetime(1995, 12, 2, 4, 0, tzinfo=timezone.utc)
print(int(back.timestamp()))  # 817876800

Exécuté avec Python 3.14.4 le 26 octobre 2026 : il affiche ce qu'indiquent les commentaires.

Chaque onglet est un programme ou une session complète qui s'exécute tel quel une fois collé ; dans l'onglet Shell, exécutez la moitié qui correspond à votre système. Source : docs.python.org, ECMA-262, Instant, DateTimeOffset, pkg.go.dev/time, PostgreSQL, MySQL, date(1), GNU Coreutils

Temps epoch : questions et réponses

Qu'est-ce que le temps epoch ?

Le temps epoch, aussi appelé temps Unix ou timestamp Unix, est le nombre de secondes écoulées depuis 1970-01-01 00:00:00 UTC, sans compter les secondes intercalaires. Les ordinateurs stockent les dates ainsi parce qu'un seul nombre est facile à comparer, trier et transmettre. Le timestamp 1000000000 correspondait à 2001-09-09 01:46:40 UTC, et le champ en haut de page convertit n'importe quelle valeur en date.

Comment convertir un epoch en date ?

Collez le nombre dans le champ en haut de page. La page le lit en secondes, millisecondes, microsecondes et nanosecondes, choisit la lecture qui tombe sur une date réelle et affiche cette date dans votre fuseau horaire et en UTC. À la main, multipliez les secondes par 1 000 et passez-les à une fonction de date, comme new Date(817876800 * 1000) en JavaScript.

Quel est le timestamp actuel ?

L'horloge de cette page affiche le temps Unix actuel en direct, en secondes, millisecondes, microsecondes et nanosecondes, et chaque valeur peut être copiée. Il vient de l'horloge de votre propre appareil et n'est donc pas plus précis qu'elle ; un ordinateur synchronisé par Internet est en général juste à une fraction de seconde près. En ligne de commande, date +%s l'affiche en secondes.

Un timestamp Unix est-il en secondes ou en millisecondes ?

Les timestamps Unix classiques sont en secondes, mais JavaScript, Java et de nombreuses API web utilisent les millisecondes, et certaines bases de données et certains journaux les microsecondes ou les nanosecondes. Un timestamp actuel a 10 chiffres en secondes et 13 en millisecondes. Si une date tombe en 1970 ou dans des milliers d'années, l'unité est fausse ; cette page essaie chaque unité et montre laquelle a du sens.

Pourquoi le temps Unix commence-t-il en 1970 ?

Aucune source primaire n'en donne la raison. Le premier manuel d'Unix, de 1971, comptait des soixantièmes de seconde depuis le 1er janvier 1971 et prévoyait d'être épuisé en quelques années. Quand le compte est passé aux secondes entières, le 1er janvier 1970 est devenu le point de départ : une date ronde proche de l'époque où Unix était écrit, à partir de laquelle un compte de secondes sur 32 bits va jusqu'en 2038.

Le temps Unix est-il identique à UTC ?

Presque, mais pas exactement. Le temps Unix suit le calendrier et l'horloge d'UTC, mais il donne à chaque jour exactement 86 400 secondes et ignore les secondes intercalaires : une seconde intercalaire n'a donc pas de timestamp propre. POSIX dit lui-même qu'un temps Unix décomposé n'est pas nécessairement de l'UTC. Pour les dates et heures que lisent les gens, la différence ne se voit jamais ; pour des intervalles précis qui traversent une seconde intercalaire, si.

Qu'est-ce que le problème de l'an 2038 ?

Un temps Unix stocké dans un nombre signé de 32 bits ne peut atteindre que 2147483647, soit 2038-01-19 03:14:07 UTC. Une seconde plus tard, il déborde et se lit comme décembre 1901. Les systèmes d'exploitation modernes utilisent un temps sur 64 bits et sont sûrs, mais des champs de 32 bits subsistent dans certaines bases de données, formats de fichiers et appareils embarqués : la colonne TIMESTAMP de MySQL, par exemple, s'arrête toujours à cette seconde.

Peut-on convertir une date antérieure à 1970 ?

Oui. Les dates antérieures à 1970 sont des timestamps négatifs : -1 correspond à 1969-12-31 23:59:59 UTC, et une date de 1950 vaut environ -631 millions. Collez un nombre négatif et la page affiche sa date ; saisissez une date plus ancienne et elle donne la valeur négative. POSIX strict laisse les valeurs négatives indéfinies et le TIMESTAMP de MySQL ne peut pas les contenir, mais la plupart des langages et bases de données les lisent comme des dates d'avant 1970.

Comment convertir un Windows FILETIME en date ?

Un FILETIME compte des intervalles de 100 nanosecondes depuis 1601-01-01 UTC : il a donc 18 chiffres aujourd'hui. Collez-le dans le champ et la page le lit comme un FILETIME à côté des unités Unix : 133756272000000000 correspond à 2024-11-09 12:00:00 UTC. À la main, soustrayez 116444736000000000 et divisez par 10 000 000 pour obtenir des secondes Unix.

Comment convertir un numéro de série Excel en timestamp ?

Un numéro de série Excel compte des jours, avec une fraction pour l'heure : dans le système 1900 par défaut, 45658 correspond au 2025-01-01. Collez le numéro de série et la page le lit comme une date Excel dans les systèmes 1900 et 1904. Excel traite 1900 comme une année bissextile à dessein, donc les numéros inférieurs à 61 sont décalés d'un jour, et la page les signale au lieu de deviner.

Le convertisseur gère-t-il les fuseaux horaires et l'heure d'été ?

Oui. La page affiche chaque date dans votre propre fuseau horaire et en UTC, et vous pouvez choisir n'importe quel fuseau IANA, comme America/New_York ou Asia/Kolkata. L'heure d'été est appliquée pour la date convertie, pas pour aujourd'hui : un timestamp d'été affiche donc l'heure d'été même en hiver. Une date saisie sans décalage est lue en UTC, et un clic la lit plutôt dans votre propre fuseau.

Mon timestamp est-il envoyé quelque part ?

Non. La conversion se fait dans votre navigateur : ce que vous collez ne quitte jamais votre appareil et aucun serveur ne le voit. Un lien créé avec « Copier le lien » contient le timestamp dans son adresse, pour que la page qu'il ouvre affiche déjà la date ; rien d'autre n'est stocké ni envoyé.

Il vous manque quelque chose ?Suggérez une fonction ou un nouvel outil