Client Hints et User-Agents sur Chrome, Safari et Firefox

Aide-mémoire Passkeys. Conseils pratiques, modèles de déploiement et KPIs pour les programmes passkeys.

Obtenir l'aide-mémoire

Les méthodes permettant de détecter et de s'adapter aux différents environnements des utilisateurs évoluent constamment. Traditionnellement, les chaînes User-Agent constituaient le moyen d'identifier les informations sur le navigateur et l'appareil, permettant aux sites web de personnaliser les expériences en conséquence. Cependant, ces chaînes ont souvent été utilisées à des fins de fingerprinting (prise d'empreinte) et d'identification des utilisateurs sans leur consentement pour des raisons marketing, soulevant ainsi des problèmes de confidentialité.

Dans ce contexte, les Client Hints sous forme d'API JavaScript sont apparus comme un outil offrant un moyen plus contrôlé et respectueux de la vie privée de partager les informations nécessaires sur l'appareil de l'utilisateur et ses préférences. Cet article se concentre sur les conséquences de la réduction du User-Agent et explore comment les Client Hints aident à s'adapter à cette nouvelle donne.

Points clés que nous aborderons :

• Qu'est-ce que la réduction du User-Agent : Comprendre la transition vers des chaînes User-Agent réduites et ses implications.
• Comment fonctionnent les Client Hints : Explorer les mécanismes derrière les Client Hints et comment ils peuvent être implémentés efficacement.

Comme les navigateurs et les systèmes d'exploitation ont des positions différentes et adaptent leurs approches différemment, les développeurs de logiciels sont confrontés au défi de s'assurer que leurs applications peuvent toujours détecter et répondre avec précision aux divers environnements des utilisateurs sur l'ensemble des navigateurs et systèmes d'exploitation.

Cet article vise à fournir un aperçu complet de ces changements, en offrant des informations et des conseils pratiques pour aider les développeurs au cas où leur cas d'usage ou leur logiciel dépendrait de détails liés à l'appareil ou aux systèmes d'exploitation (par exemple, la gestion détaillée des appareils, la détection des appareils connus, la prévention de la fraude ou d'autres détections de fonctionnalités) ou, comme dans notre propre cas, pour optimiser l'expérience des clés d'accès avec le User-Agent et les Client Hints.

Avant de plonger dans les détails techniques des Client Hints, nous explorerons brièvement l'histoire du User-Agent et comment fonctionnent les différents efforts de réduction du User-Agent.

L'histoire des chaînes User-Agent remonte à la création des premiers navigateurs web. Tim Berners-Lee a développé le premier navigateur web, WorldWideWeb (renommé plus tard Nexus) en 1990. Il a été rapidement suivi par d'autres navigateurs pionniers comme Line Mode Browser en 1991, puis des navigateurs tels que MidasWWW, ViolaWWW, Erwise et Cello sont apparus.

En 1993, la sortie de NCSA Mosaic, souvent appelé simplement Mosaic, est reconnue pour avoir déclenché l'engouement initial pour le web. La chaîne User-Agent de Mosaic était assez simple, généralement formatée comme NCSA_Mosaic/1.0, présentant le nom du produit suivi d'une barre oblique facultative et du numéro de version.

Initialement, le champ User-Agent a été introduit à des fins analytiques et pour aider à identifier les problèmes. Il a été explicitement recommandé que ce champ « devrait être inclus » dans les requêtes HTTP, comme indiqué dans les archives HTTP du W3C de 1992. Ce champ simple offrait un moyen efficace de transmettre le nom et la version du produit, aidant ainsi à comprendre et à résoudre les problèmes liés au navigateur.

À mesure que le web évoluait, la complexité et l'utilisation des chaînes User-Agent ont également augmenté. Elles sont devenues plus détaillées et ont commencé à inclure une multitude d'informations sur le navigateur, le système d'exploitation et l'appareil. Bien que ces informations aient été précieuses pour l'analyse web et l'optimisation des expériences utilisateur, elles posaient également des problèmes importants de confidentialité. Des chaînes User-Agent détaillées permettaient le fingerprinting des appareils, offrant aux annonceurs et aux traqueurs la possibilité de créer des profils uniques d'utilisateurs et de suivre leurs activités en ligne sur différents sites web.

À l'ère moderne, où la confidentialité est devenue une préoccupation majeure pour les utilisateurs comme pour les régulateurs, la nature détaillée des chaînes User-Agent a été de plus en plus considérée comme problématique. Cette prise de conscience a conduit à des efforts visant à réduire la granularité des chaînes User-Agent, avec pour objectif de trouver un équilibre entre la fourniture d'informations nécessaires au fonctionnement du web et la protection de la vie privée des utilisateurs. Cette transition marque le début de la réduction du User-Agent, un mouvement visant à minimiser les informations partagées dans les chaînes User-Agent pour atténuer les risques liés à la confidentialité et améliorer la sécurité.

Le mouvement vers la réduction du User-Agent a commencé en réponse aux préoccupations croissantes concernant la confidentialité. Voici un aperçu chronologique des jalons clés de cette évolution :

En 2017, Apple a initié le mouvement de réduction du User-Agent avec une célèbre publication sur Twitter annonçant que Safari gèlerait la chaîne User-Agent dans Safari Technology Preview 46 (STP 46), dans le but de lutter contre le fingerprinting et d'améliorer la confidentialité.

Cependant, cette décision a été plus tard partiellement annulée en 2021 en raison de problèmes de compatibilité importants avec les sites web qui s'appuyaient sur des informations User-Agent à jour.

En 2019/2020, Google a annoncé son intention de réduire la granularité des chaînes User-Agent dans Chrome, en introduisant les User-Agent Client Hints (UA-CH) comme un moyen flexible et contrôlé de demander des informations spécifiques sur le navigateur et l'appareil. Google a commencé à tester la réduction du User-Agent dans les versions Canary et Beta de Chrome, recueillant des commentaires pour garantir la compatibilité et les fonctionnalités, et a terminé le processus en 2023 pour Android et toutes les autres plateformes Chrome. En même temps, Chrome a introduit les Client Hints comme un nouveau moyen d'accéder à ces informations. Comme Microsoft Edge est basé sur Chromium, Microsoft Edge se comporte comme Chrome sur toutes les plateformes.

En 2021, Mozilla a rejoint l'effort, en réduisant progressivement la granularité de la chaîne User-Agent, mais Mozilla a décidé de ne pas prendre en charge les Client Hints dans Firefox.

• La réduction du User-Agent varie selon le navigateur : Chromium (Chrome, Edge) a mis en œuvre la réduction complète du UA avec la prise en charge des Client Hints. Cependant, Safari utilise sa propre approche de UA gelé sans adopter les UA-CH, et Firefox n'a pas implémenté navigator.userAgentData. L'écosystème reste fragmenté.

• Les Client Hints ont évolué au sein de Chromium : Tous les navigateurs envoient toujours un en-tête User-Agent, mais dans la plupart d'entre eux, il est gelé à une ancienne version (voir le tableau ci-dessous). Pour Chromium, les Client Hints peuvent être utilisés pour obtenir plus d'informations.

Voyons ce que les navigateurs envoient actuellement en tant que User-Agents dans le chapitre suivant.

Abonnez-vous à notre Substack passkeys pour les dernières actualités.

S'abonner

Lorsqu'on parle de réduction du User-Agent, il s'agit de réduire les informations contenues dans la chaîne User-Agent. Allons plus loin pour découvrir ce qui était intégré au User-Agent avant la réduction.

Une chaîne User-Agent classique comprenait généralement les composants suivants, qui pouvaient être utilisés pour détecter des fonctionnalités :

Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.2.1.0 Mobile Safari/537.36

• Système d'exploitation : Le nom du système d'exploitation (par exemple, Windows, macOS, Linux).
• Numéro de version du système d'exploitation : La version spécifique du système d'exploitation.
• Nom du navigateur : Le nom du navigateur (par exemple, Chrome, Firefox, Safari).
• Version du navigateur : La version spécifique du navigateur.
• Architecture : L'architecture du système (par exemple, x86, ARM).
• Type/Modèle d'appareil : Informations sur le type ou le modèle d'appareil (par exemple, iPhone, Pixel).
• Autres informations : Cela peut inclure des détails supplémentaires comme la plateforme, le numéro de build, etc.

Historiquement, les chaînes User-Agent étaient souvent utilisées pour la détection de fonctionnalités et de plateformes, permettant aux sites web d'adapter leur contenu et leurs fonctionnalités en fonction des caractéristiques détectées du navigateur et de l'appareil (par exemple, déterminer quel téléchargement de binaire spécifique proposer). Cela est devenu particulièrement important avec l'essor des téléphones mobiles et des tablettes pour les mises en page qui n'étaient pas conçues pour être responsives afin de pouvoir rediriger les téléphones mobiles vers leur version spécifique.

Cependant, cette approche est aujourd'hui considérée comme sous-optimale, car elle repose sur des hypothèses concernant les capacités du navigateur qui peuvent ne pas se vérifier ou ne pas être assez spécifiques. Les pratiques modernes de développement web préconisent d'utiliser la détection de fonctionnalités via les API du navigateur lorsque cela est possible, afin de vérifier directement les fonctionnalités et capacités spécifiques du navigateur. Cette méthode est plus fiable et garantit que les sites web fonctionnent correctement indépendamment de la chaîne User-Agent ou de la version du navigateur. La détection de fonctionnalités se concentre sur les capacités réelles du navigateur, offrant un moyen plus robuste et pérenne de gérer les différences de comportement et de fonctionnalités entre navigateurs.

À ce jour, cela n'est pas entièrement possible car les nouvelles API des navigateurs permettant de détecter des fonctionnalités sont implémentées à des moments différents et il y a souvent une approche différente entre les équipes de navigateurs majeurs (par exemple, les navigateurs basés sur Chromium) et les plus petites équipes (par exemple, Firefox).

Plus d'informations donnent à un site web une plus grande possibilité de créer une empreinte avec plus d'« entropie ». L'entropie dans ce contexte correspond à la quantité de variation qui peut être utilisée pour générer une empreinte unique parmi les différents visiteurs d'un site web.

Une empreinte peut être utilisée à différentes fins. Elle peut servir à des fins de protection, comme la détection des fraudes et l'arrêt des prises de contrôle de compte en identifiant de nouveaux appareils, mais elle peut aussi être utilisée pour identifier les visiteurs sans leur consentement ou pour un ciblage publicitaire plus précis.

Dans le contexte des chaînes User-Agent, l'entropie désigne la quantité d'informations uniques et identifiables qui peuvent être utilisées pour suivre et distinguer les utilisateurs individuels.

• Informations à forte entropie : Comme les versions spécifiques du navigateur et de l'OS, elles contribuent de manière significative à l'unicité de l'empreinte d'un utilisateur, facilitant ainsi son suivi sur différents sites web.
• Informations à faible entropie : Noms généraux des navigateurs ou des systèmes d'exploitation, elles fournissent des données moins détaillées et contribuent moins au suivi des utilisateurs car davantage d'utilisateurs partagent ces combinaisons.

Il existe de nombreuses autres informations qui peuvent être utilisées comme source d'entropie au-delà du User-Agent. Par exemple, vous pouvez trouver différentes sources d'entropie sur https://coveryourtracks.eff.org.

Par conséquent, lorsque les navigateurs parlent de réduction du User-Agent, ils visent principalement à réduire les informations à forte entropie. Voici différents exemples de cette réduction :

Ci-dessous, vous trouverez un exemple de la réduction du User-Agent de Google Chrome sur un téléphone Android :

Avant : Mozilla/5.0 (Linux; Android <span style={{color: '#016F01' }}>13; Pixel 7</span>) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.0.0 Mobile Safari/537.36

Après : Mozilla/5.0 (Linux; Android <span style={{color: '#016F01' }}>10; K</span>) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.0.0 Mobile Safari/537.36

Le format du User-Agent est resté inchangé afin de ne pas interférer avec la logique d'analyse existante des bibliothèques. Les valeurs suivantes ont été réduites :

• Version du système d'exploitation
• Version mineure du navigateur
• Modèle matériel
  

Le graphique détaille quelles valeurs continueront d'être mises à jour en fonction du système d'exploitation et les valeurs en vert montrent quelles valeurs seront constantes sur toutes les plateformes. Pour les différentes valeurs de système d'exploitation, seule une variante restant constante sera disponible :

Ci-dessous, vous trouverez un exemple de la réduction du User-Agent de Mozilla Firefox qui s'aligne en grande partie sur les positions de Google concernant la réduction du User-Agent.

Voici un exemple de User-Agent sur Windows 11 avec une version actuelle de Firefox :

Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0

Dans ce User-Agent, l'architecture du CPU, la version du système d'exploitation et la version mineure du navigateur ont été gelées.

Ci-dessous, vous trouverez un exemple de réduction du User-Agent Safari sur macOS.

Commençons tout d'abord par un User-Agent Safari sur macOS Sonoma Version 14.5 sur Mac Silicon M2.

Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15

Vous pouvez voir que la version de macOS est bloquée à 10_15_07 et l'architecture est également fixée à Intel ne signalant pas l'architecture CPU Mac. C'est également vrai pour Firefox et Chrome sur macOS.

Avant iOS 26 (sorti en septembre 2025), Safari sur iOS exposait la version réelle du système d'exploitation. Cependant, Apple a désormais gelé le User-Agent d'iOS/iPadOS dans Safari 26, de manière similaire à macOS. L'exemple ci-dessous montre un User-Agent antérieur à iOS 26 :

Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1

Remarque : À partir d'iOS 26, tous les navigateurs sur iOS (Chrome, Firefox, Safari) ont désormais des chaînes User-Agent gelées, similaires à macOS. Les exemples ci-dessous montrent le comportement avant iOS 26 :

Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/126.0.6478.153 Mobile/15E148 Safari/604.1

Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/127.1 Mobile/15E148 Safari/605.1.15

Dans l'ensemble, il est évident que le User-Agent est réduit spécifiquement sur les informations à forte entropie. L'aperçu suivant montre sur quelles combinaisons plateforme / système d'exploitation le User-Agent est réduit.

Par conséquent, les problèmes de détection les plus importants avec un User-Agent réduit sont (* = voir les remarques ci-dessous pour la version macOS) :

• Windows 10 et Windows 11 ne peuvent pas être distingués : Vous ne pouvez plus faire la distinction entre les systèmes Windows 10 et Windows 11 en vous basant uniquement sur le User-Agent.
• Les appareils Android et la version du système d'exploitation ne peuvent pas être distingués : Contrairement à Apple, Android incluait auparavant le modèle matériel réel dans le User-Agent. Ce n'est plus le cas. Par conséquent, différents modèles de matériel ne peuvent plus être distingués uniquement via le User-Agent. Avec Apple, cela n'a jamais été possible.
• La version et l'architecture de macOS ne peuvent pas être distinguées : Il n'y a aucun moyen de différencier les versions de macOS et les architectures de plateforme en se basant sur le User-Agent.
• (*) Version de macOS sur Safari : Safari a gelé la version du système d'exploitation mais continue d'afficher la version de Safari. Au moment de la rédaction de cet article, pour la version 10.15 et les versions ultérieures, il est sûr de soustraire trois à la version de Safari pour détecter la version majeure de macOS.
• (**) Version d'iOS sur Safari 26+ : À partir d'iOS 26 (septembre 2025), Apple a gelé le User-Agent d'iOS/iPadOS, de la même manière que macOS. La version de l'OS n'est plus exposée.

Voici un tableau associant les versions de macOS à leurs versions Safari correspondantes :

Il existe d'autres moyens de détecter les systèmes d'exploitation et les navigateurs grâce à des techniques de fingerprinting élaborées, comme le fingerprinting TLS. Comme il y a des scénarios légitimes où une détection plus approfondie du système d'exploitation aurait du sens, Google a introduit les Client Hints pour pouvoir recevoir ces informations par programmation. Nous verrons comment fonctionnent les Client Hints dans le chapitre suivant.

Les Client Hints permettent aux sites web d'accéder aux informations à forte entropie qui ont été supprimées de la chaîne User-Agent de manière respectueuse de la vie privée. Il existe deux méthodes principales pour accéder aux Client Hints :

• En-tête HTTP : Utilisation d'en-têtes de requête HTTP, disponibles uniquement pour les contextes propriétaires (first-party).
• API JavaScript : Utilisation d'une API JavaScript, qui peut être utilisée par un script intégré.

Les Client Hints peuvent également être utilisés pour récupérer les informations à faible entropie qui sont déjà incluses dans le User-Agent. Cela implique que sur Chrome, où les Client Hints sont pris en charge, les User-Agents ne sont plus nécessaires.

Selon la méthode d'accès utilisée, la dénomination des Client Hints diffère légèrement. Nous avons listé les noms de Client Hints les plus importants :

Dans un contexte propriétaire (first-party), les sites web peuvent demander des informations spécifiques sur le navigateur et l'appareil de l'utilisateur à l'aide des en-têtes de requête HTTP. Cette approche implique de définir le bon en-tête dans la réponse HTTP du serveur, indiquant quels Client Hints intéressent le serveur. Le navigateur inclut ensuite ces indices dans les requêtes ultérieures vers la même origine.

Cet en-tête indique au navigateur d'envoyer des informations détaillées sur l'utilisateur dans les requêtes futures, permettant au serveur d'adapter ses réponses en conséquence. Cette méthode garantit que les informations détaillées sur l'utilisateur ne sont accessibles qu'au site web propriétaire, empêchant les ressources tierces d'obtenir des données à forte entropie. Il existe deux types d'en-têtes de requête disponibles dont nous allons discuter maintenant :

• Les en-têtes Client Hint standards
• Les en-têtes Critical (Client) Hint

Les Client Hints standards sont des en-têtes qu'un serveur peut demander au navigateur pour recueillir des informations sur l'environnement de l'utilisateur lors de requêtes ultérieures.

Exemple : Chrome sur macOS 14.5 avec des Client Hints standards sur corbado.com

1. Lors de la première requête vers Corbado.com, Chrome inclura déjà les en-têtes à faible entropie suivants car ces informations sont également incluses dans le User-Agent.

2. Disons que Corbado.com aimerait recevoir la version du système d'exploitation (platform version) lors des requêtes ultérieures. Par conséquent, il définirait l'en-tête « Sec-CH-UA-Platform-Version » approprié dans la réponse à la première requête :

3. Lors des requêtes ultérieures, Corbado.com recevrait alors un en-tête supplémentaire avec la version de la plateforme :

Dans le même temps, le User-Agent pour cette requête restera le même (sans la version de la plateforme) :

Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36

En utilisant https://user-agent-client-hints.glitch.me/headers, vous pouvez jouer avec la façon dont les différentes dispositions d'informations se présenteraient pour les indices standards (gardez à l'esprit que vous devez utiliser Chrome). Voir ici pour plus de détails. Au cas où corbado.com aurait besoin de ces informations dès la première requête de page, l'utilisation de Client Hints standards ne serait pas suffisante, mais il existe un moyen d'accélérer ce processus avec les Critical (Client) Hints.

Imaginons que corbado.com ait besoin de la version de la plateforme dès la première requête pour afficher une page de téléchargement appropriée, adaptée à la version exacte de macOS. Il pourrait utiliser les Critical (Client) Hints, ce qui conduirait à une nouvelle tentative immédiate de la requête pour n'afficher la page qu'en incluant l'en-tête :

Exemple : Chrome sur macOS 14.5 avec des Critical Client Hints sur corbado.com

1. Lors de la première requête pour corbado.com, Chrome inclura déjà les en-têtes à faible entropie suivants car ces informations sont également incluses dans le User-Agent.

2. Disons que corbado.com souhaiterait recevoir la version du système d'exploitation (platform version) lors du premier rendu de la page. Il définirait alors l'en-tête Critical Client Hint « Sec-CH-UA-Platform-Version » dans la réponse à la première requête :

3. Chrome ne commencerait pas le rendu et relancerait immédiatement la requête, de sorte que l'en-tête soit disponible lors du premier rendu de corbado.com. Il recevrait alors l'en-tête supplémentaire avec la version de la plateforme :

Dans les graphiques suivants, nous voyons un autre exemple où le site web demande le modèle d'appareil comme partie critique avec l'en-tête Critical-CH. Comme nous pouvons le voir, le client relance la requête comme dans l'exemple ci-dessus (graphique de séquence de gauche).

Client Hints avec Chromium : https://developers.google.com/privacy-sandbox/protections/User-Agent

L'utilisation de Critical Client Hints ajoute donc de la latence car le navigateur doit lancer immédiatement une deuxième requête, ce qui ajoute des allers-retours. Il existe un moyen d'optimiser le transfert en facilitant l'établissement de la liaison TLS (la boîte verte en haut du graphique) pour transmettre d'ores et déjà les détails. Cette approche facilitant l'ALPN (Application-Layer Protocol Negotiation) est détaillée ici, mais dépasse le cadre de cet article.

Pour recevoir des informations supplémentaires à l'aide des en-têtes, une configuration doit être ajoutée soit au backend, soit au serveur web / équilibreurs de charge. Cela se fait facilement dans un contexte de site web propriétaire, lorsque vous avez le contrôle total du site web en tant qu'entreprise. Par exemple, nos composants d'interface utilisateur sur corbado.com nécessitent la version de la plateforme pour augmenter la précision de notre intelligence des clés d'accès. Les développeurs intègrent nos composants sur diverses pages et exiger qu'ils ajoutent des en-têtes puis transmettent ces informations à nos composants représenterait une surcharge désagréable. Pour les SPA et autres applications JavaScript intégrées, il existe une autre interface qui peut être utilisée et qui sera expliquée dans la section suivante.

En utilisant la fonction navigator.userAgentData.getHighEntropyValues(), les Client Hints peuvent également être accédés via une API JavaScript, offrant un moyen flexible et dynamique de demander des informations spécifiques sur le navigateur et l'appareil de l'utilisateur. Cette méthode implique l'utilisation de l'objet navigator.userAgentData au sein du script de la page web pour demander des Client Hints. Cette méthode ne nécessite pas que les en-têtes Client Hint soient définis, mais elle ne fonctionne que dans les navigateurs qui prennent en charge navigator.userAgentData (les navigateurs basés sur Chromium comme Chrome et Edge). Firefox et Safari ne prennent pas en charge cette API, les développeurs doivent donc détecter les fonctionnalités et prévoir des solutions de repli.

Par exemple, lors de l'exécution de ce code dans une console Chrome sur macOS :

if (navigator.userAgentData) {
    navigator.userAgentData
        .getHighEntropyValues(["architecture", "model", "platformVersion"])
        .then((ua) => {
            console.log(ua);
        });
}

Lorsque la promesse est résolue, les informations pertinentes sont retournées. Comme nous l'avons souligné plus haut, les noms ne sont pas complètement identiques aux en-têtes mais en sont très proches.

La platformVersion est ensuite retournée dans la promesse et elle peut être accédée directement depuis le code JavaScript intégré. La couverture de cette fonction est bien inférieure à la loi de réduction réelle du User-Agent :

De plus, Chrome ne propose pas cette fonctionnalité sur iOS car il déploie WebKit sur iOS en raison des limitations d'Apple.

Nous avons maintenant rassemblé les faits les plus importants concernant la réduction du User-Agent et la façon dont les Client Hints offrent un moyen de la contourner dans Chrome.

En fonction de votre cas d'usage, vous devriez utiliser une approche différente pour vous assurer que votre application obtient le meilleur résultat possible :

• Détection de fonctionnalités : Utilisez les API JavaScript de navigateur existantes dans la mesure du possible. Chaque fois que cela est faisable, appuyez-vous sur les API du navigateur pour détecter directement les fonctionnalités, plutôt que d'utiliser le User-Agent. C'est plus fiable et plus pérenne.
• Pour les informations à faible entropie, des indices comme le type d'appareil : Le User-Agent est suffisant. Si votre application a seulement besoin de déterminer le type d'appareil ou d'autres détails à faible entropie, la chaîne User-Agent sera suffisamment détaillée. Vous pouvez également utiliser les API existantes à ces fins.
• Pour les informations à forte entropie et le contrôle du domaine : Utilisez l'approche par en-tête. Si vous avez besoin d'informations détaillées et que vous contrôlez le domaine, utilisez l'approche des en-têtes HTTP pour demander des informations à forte entropie là où elles sont prises en charge (Chrome, Edge). Sur tous les autres navigateurs (qui n'envoient pas d'en-têtes Client Hint), utilisez le User-Agent classique. Décidez si vous devez utiliser les Critical Client Hints selon que vous avez besoin des informations immédiatement ou si vous pouvez vous permettre un léger retard.
• Pour les bibliothèques JavaScript : Utilisez getHighEntropyValues. Si vous développez une bibliothèque JavaScript, la meilleure option est d'utiliser la fonction navigator.userAgentData.getHighEntropyValues() pour demander dynamiquement des informations spécifiques sur le navigateur et l'appareil de l'utilisateur chaque fois que cette fonction est définie, et de vous rabattre sur des bibliothèques d'analyse de User-Agent dans les autres cas.

Le tableau suivant résume où vous êtes toujours en mesure de détecter la version du système d'exploitation si vous avez accès au User-Agent (UA) et aux Client Hints (CH) :

En choisissant la méthode appropriée en fonction de vos besoins spécifiques, vous pouvez équilibrer efficacement le besoin d'informations détaillées sur l'utilisateur avec les considérations de confidentialité et de performance. Si vous dépendez fortement d'informations difficiles à extraire ou réellement basées sur l'appareil, rabattez-vous sur des bibliothèques professionnelles comme wurfl ou 51degrees.com qui font le travail à votre place. Les deux bibliothèques prennent en charge l'intégration des Client Hints dans la détection et ont également leur propre méthode propriétaire pour détecter même les modèles d'iPhone.

Chez Corbado, nous nous concentrons sur le développement de solutions autour des clés d'accès (passkeys) en utilisant des composants d'interface utilisateur principalement développés avec React. Nos composants sont intégrés à divers sites web, nous suivons donc notre propre recommandation et utilisons getHighEntropyValues() partout où cela est disponible, en nous rabattant sur l'analyse classique du User-Agent pour tous les autres cas. Nous l'utilisons principalement pour :

• La gestion des clés d'accès : Sur notre site de gestion des clés d'accès, nous affichons toutes les informations disponibles sur l'appareil où la clé d'accès a été créée.
• L'authentification multi-appareils : Pour l'authentification cross-device, nous utilisons les informations sur le système d'exploitation pour déterminer la probabilité que le client prenne en charge l'utilisation de la CDA. C'est particulièrement important pour faire la différence entre Windows 10 et 11, ce qui n'est possible qu'avec les Client Hints sur Chrome et Edge :

Plus de détails sur : https://learn.microsoft.com/en-us/microsoft-edge/web-platform/how-to-detect-win11

• L'intelligence des clés d'accès : Nous pensons que la plateforme devrait décider si une connexion par clé d'accès doit être initiée. Par conséquent, nous intégrons autant de logique que possible dans nos composants pour détecter si un nouvel appareil est utilisé. Dans de tels scénarios, une nouvelle version ou une version mineure du système d'exploitation est un indice précieux indiquant que les choses ont peut-être changé.

Lorsque nous avons commencé à compiler des informations pour nos composants, nous avons trouvé beaucoup de données fragmentées créées pendant ou avant le début de la réduction du User-Agent. Par conséquent, nous avons pensé qu'un résumé aiderait les développeurs qui souhaitent améliorer la détection mais qui ne travaillent pas régulièrement avec les User-Agents ou les Client Hints.

Après que la détection basée sur le User-Agent a été la norme pendant des décennies, les chaînes User-Agent sont devenues moins détaillées pour protéger la vie privée des utilisateurs. Dans cet article, nous avons couvert :

• Qu'est-ce que la réduction du User-Agent ? La réduction du User-Agent est le processus de minimisation de la quantité d'informations partagées via les chaînes User-Agent afin de protéger la vie privée des utilisateurs. Cette transition réduit la granularité de données telles que la version du système d'exploitation et le modèle matériel, qui étaient auparavant utilisés pour le fingerprinting et le suivi des utilisateurs sur différents sites web. Nous avons exploré comment cette réduction affecte les développeurs et comment ils peuvent s'adapter à ces changements.
• Comment fonctionnent les Client Hints ? Les Client Hints fournissent un mécanisme pour demander des informations spécifiques à forte entropie sur l'appareil de l'utilisateur de manière plus respectueuse de la vie privée. En utilisant des en-têtes HTTP et des API JavaScript, les développeurs peuvent accéder à des données détaillées sur l'environnement de l'utilisateur lorsque cela est nécessaire. Nous avons discuté de la manière dont les Client Hints sont implémentés, des types d'indices disponibles et des méthodes pour y accéder via les en-têtes de requête HTTP et JavaScript.

Les Client Hints continuent d'évoluer, et leur adoption pourrait augmenter à mesure que davantage de navigateurs et de développeurs en reconnaissent les avantages. Cependant, il reste à voir si leur prise en charge se généralisera ou si le web continuera à diverger sur ce sujet.

À propos de Corbado

Corbado est la Authentication Intelligence Platform pour les équipes CIAM qui gèrent l'authentification client à grande échelle. Nous vous montrons ce que les logs IDP et les outils d'analytics génériques ne voient pas : quels appareils, versions d'OS, navigateurs et gestionnaires de credentials prennent en charge les passkeys, pourquoi les enrôlements ne deviennent pas des connexions, où le flux WebAuthn échoue et quand une mise à jour OS ou navigateur casse silencieusement la connexion — le tout sans remplacer Okta, Auth0, Ping, Cognito ni votre IDP interne. Deux produits : Corbado Observe ajoute l'observabilité pour les passkeys et toute autre méthode de connexion. Corbado Connect apporte des passkeys managés avec analytics intégrés (aux côtés de votre IDP). VicRoads gère les passkeys pour plus de 5M d'utilisateurs avec Corbado (+80 % d'activation passkey). Parler à un expert Passkey →

Apple a gelé la chaîne User-Agent d'iOS/iPadOS dans Safari 26, sorti en septembre 2025, ce qui signifie que la version du système d'exploitation n'est plus exposée via le User-Agent sur aucun navigateur fonctionnant sous iOS. Contrairement à Chrome sur Android ou sur ordinateur, aucune API Client Hints n'est disponible sur les navigateurs iOS, la version réelle d'iOS n'est donc plus accessible par programmation.

Les Client Hints standards, demandés via l'en-tête de réponse Accept-CH, ne sont inclus que dans les requêtes ultérieures et ne sont pas disponibles lors du chargement initial de la page. Les Critical Client Hints déclenchent une nouvelle tentative immédiate du navigateur avant le rendu, garantissant que l'information est disponible au premier rendu, mais cela ajoute un aller-retour de latence au cycle de la requête.

Apple a annoncé le gel du User-Agent dans Safari Technology Preview 46 en 2017, mais est partiellement revenu sur cette décision en 2021 en raison de problèmes de compatibilité importants avec les sites web s'appuyant sur des informations User-Agent à jour. Apple a par la suite mis en œuvre une approche de gel du UA plus graduelle plutôt qu'un gel complet et immédiat à l'époque.

Safari ne prend pas en charge les Client Hints, mais la version de macOS peut être déduite du numéro de version de Safari dans la chaîne User-Agent. Soustraire trois à la version majeure de Safari correspond de manière fiable à la version majeure de macOS pour macOS 10.15 et supérieur, en raison de l'alignement cohérent des versions entre Safari et macOS.

L'approche recommandée consiste à appeler navigator.userAgentData.getHighEntropyValues() lorsque la fonction est définie, couvrant les navigateurs basés sur Chromium, et à se rabattre sur des bibliothèques d'analyse de chaînes User-Agent pour Firefox et Safari. Pour les cas nécessitant une identification de modèle d'appareil très spécifique, des bibliothèques professionnelles telles que wurfl ou 51degrees offrent des capacités de détection supplémentaires au-delà de ce que les chaînes User-Agent exposent.