---
url: 'https://www.corbado.com/fr/blog/client-hints-user-agent-chrome-safari-firefox'
title: 'Client Hints et User-Agents sur Chrome, Safari et Firefox'
description: 'Découvrez la prise en charge des API User-Agent et Client Hints sur Chrome, Safari et Firefox, et comment nous les utilisons pour les clés d''accès.'
lang: 'fr'
author: 'Vincent Delitz'
date: '2026-07-27T08:23:47.359Z'
lastModified: '2026-07-27T08:25:49.237Z'
keywords: 'réduction user-agent, user-agent, client hints, api client hints, user-agent string, client hints chrome, prise en charge navigateur client hints'
category: 'Engineering'
---
# Client Hints et User-Agents sur Chrome, Safari et Firefox
## Key Facts
- **La réduction du User-Agent** est achevée sur tous les principaux navigateurs : Chrome et Edge depuis 2023, Firefox partiellement et Safari est gelé depuis iOS 26, sorti en septembre 2025.
- **Firefox ne prend pas en charge les Client Hints** ou `navigator.userAgentData`, obligeant les développeurs à se rabattre sur l'analyse classique de la chaîne User-Agent sur le navigateur de Mozilla.
- L'API JavaScript **`getHighEntropyValues()`** accède aux données d'appareil à forte entropie uniquement dans les navigateurs Chromium. Safari et Firefox en sont totalement dépourvus.
- **La distinction entre Windows 10 et Windows 11** est impossible uniquement via les chaînes User-Agent. Seuls les Client Hints sur Chrome et Edge peuvent révéler la version réelle de la plateforme.
- Corbado utilise les Client Hints pour **l'intelligence des clés d'accès** : la détection de nouveaux appareils et l'évaluation de l'éligibilité à l'authentification multi-appareils, particulièrement pour différencier les versions de Windows.
## 1. Introduction : Que sont les Client Hints et la réduction du User-Agent ?
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.
### 1.1 Une brève histoire 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](https://en.wikipedia.org/wiki/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é**.
### 1.2 Introduction à la réduction du User-Agent et aux Client Hints
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 :
#### 1.2.1 Les User-Agents dans Safari
En 2017, Apple a initié le mouvement de réduction du User-Agent **[avec une célèbre publication sur Twitter](https://x.com/rmondello/status/943545865204989953)** 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.
#### 1.2.2 Les User-Agents dans Chrome (+ Edge)
En 2019/2020, **[Google a annoncé son intention](https://groups.google.com/a/chromium.org/g/blink-dev/c/-2JIRNMWJ7s/m/u-YzXjZ8BAAJ)** de réduire la granularité des chaînes User-Agent dans Chrome, en introduisant les **[User-Agent Client Hints (UA-CH)](https://chromestatus.com/feature/5704553745874944)** 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](https://www.chromium.org/updates/ua-reduction/)** 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.
#### 1.2.3 Les User-Agents dans Firefox
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**.
#### 1.2.4 Les User-Agents aujourd'hui (Mis à jour en septembre 2025)
- **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.
## 2. Qu'est-ce que la réduction du User-Agent ?
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.
### 2.1 Qu'est-ce qu'un User-Agent classique ?
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.
#### 2.1.1 Pourquoi utiliser le User-Agent pour la détection de fonctionnalités ?
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).
#### 2.1.2 Comprendre l'entropie dans le fingerprinting : Pourquoi fournir trop d'informations pose-t-il problème ?
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](https://coveryourtracks.eff.org).
### 2.2 Réduction de l'entropie du User-Agent
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 :
#### 2.2.1 Exemple 1 : Réduction du User-Agent Chrome
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 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.0.0 Mobile Safari/537.36`
**Après :**
`Mozilla/5.0 (Linux; Android 10; K) 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 :
| **Système d'exploitation** | **Nom réduit/fixé** |
| -------------------------- | --------------------------------- |
| Mac | Macintosh; Intel Mac OS X 10_15_7 |
| Windows | Windows NT 10.0; Win64; x64 |
| ChromeOS | X11; CrOS x86_64 14541.0.0 |
| Linux | X11; Linux x86_64 |
| Android | Linux; Android 10; K |
| iOS | réduit (iOS 26+) |
#### 2.2.2 Exemple 2 : Réduction du User-Agent Firefox
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.
#### 2.2.3 Exemple 3 : Réduction du User-Agent Safari sur macOS
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](https://issues.chromium.org/issues/40167872) sur macOS.
#### 2.2.4 Exemple 4 : User-Agent Safari sur iOS (Désormais réduit dans iOS 26+)
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`
### 2.3 Limitations de détection avec la réduction du User-Agent
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.
| **Navigateur** | **Windows** | **MacOS** | **iOS** | **Android** |
| ---------------- | ----------- | --------- | ------------------------ | --------------------------- |
| Chrome | réduit | réduit | réduit (iOS 26+) | réduit |
| Edge | réduit | réduit | réduit (iOS 26+) | réduit |
| Firefox | réduit | réduit | réduit (iOS 26+) | réduit |
| Safari | - | réduit\* | réduit (Safari 26+)\*\* | - |
| Samsung Internet | - | - | - | réduit |
| WebViews | - | - | réduit (iOS 26+) | non réduit (≥ 16: 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 :
| **Version de macOS** | **Version de Safari** | **Année de sortie** |
| ---------------------- | --------------------- | ------------------- |
| macOS Sequoia (15) | Safari 18 | 2024 |
| macOS Sonoma (14) | Safari 17 | 2023 |
| macOS Ventura (13) | Safari 16 | 2022 |
| macOS Monterey (12) | Safari 15 | 2021 |
| macOS Big Sur (11) | Safari 14 | 2020 |
| macOS Catalina (10.15) | Safari 13 | 2019 |
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.
## 3. Comment fonctionnent les Client Hints ?
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.
### 3.1 Quels Client Hints existent ?
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 :
| **Jeton HTTP UA-CH** | **API JS UA-CH** | **Entropie** |
| -------------------------- | ---------------------------- | ------------ |
| Sec-CH-UA-Platform-Version | UADataValues.platformVersion | Élevée |
| Sec-CH-UA-Mobile | NavigatorUAData.mobile | Faible |
| Sec-CH-UA-Model | UADataValues.model | Élevée |
| Sec-CH-UA | NavigatorUAData.brands | Faible |
| Sec-CH-UA-Arch | UADataValues.architecture | Élevée |
### 3.2 Comment accéder aux Client Hints via les en-têtes de requête HTTP
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
#### 3.2.1 Comment utiliser les en-têtes Client Hint standards ?
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.
| **En-tête** | **Valeur** |
| ------------------ | ----------------------------------------------------------------- |
| Sec-Ch-Ua | "Google Chrome";v="125", "Chromium";v="125", "Not.A/Brand";v="24" |
| Sec-Ch-Ua-Mobile | ?0 |
| Sec-Ch-Ua-Platform | "macOS" |
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 :
| **En-tête** | **Valeur** |
| ----------- | -------------------------- |
| Accept-CH | Sec-CH-UA-Platform-Version |
3. Lors des **requêtes ultérieures**, Corbado.com recevrait alors un en-tête supplémentaire avec la version de la plateforme :
| **En-tête** | **Valeur** |
| ------------------ | ----------------------------------------------------------------- |
| Sec-Ch-Ua | "Google Chrome";v="125", "Chromium";v="125", "Not.A/Brand";v="24" |
| Sec-Ch-Ua-Mobile | ?0 |
| Sec-Ch-Ua-Platform | "macOS" |
| Sec-Ch-Ua-Platform | "14.5.0" |
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](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](https://github.com/WICG/ua-client-hints) 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.
#### 3.2.2 Comment utiliser les en-têtes Critical (Client) Hint ?
Imaginons que [corbado.com](https://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.
| **En-tête** | **Valeur** |
| ------------------ | ----------------------------------------------------------------- |
| Sec-CH-UA | "Google Chrome";v="125", "Chromium";v="125", "Not_A/Brand";v="24" |
| Sec-CH-UA-Mobile | ?0 |
| Sec-CH-UA-Platform | "macOS" |
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 :
| **En-tête** | **Valeur** |
| ----------- | -------------------------- |
| Accept-CH | Sec-CH-UA-Platform-Version |
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 :
| **En-tête** | **Valeur** |
| -------------------------- | ----------------------------------------------------------------- |
| Sec-CH-UA | "Google Chrome";v="125", "Chromium";v="125", "Not_A/Brand";v="24" |
| Sec-CH-UA-Mobile | ?0 |
| Sec-CH-UA-Platform | "macOS" |
| Sec-CH-UA-Platform-Version | "14.5.0" |
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](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](https://en.wikipedia.org/wiki/Application-Layer_Protocol_Negotiation) (Application-Layer Protocol Negotiation)** est détaillée [ici](https://docs.google.com/document/d/1HQd3vosjFls2jp6DwpkNMUN4CBdmmxZJJz0WhhcqOPw/edit), 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](https://docs.corbado.com/corbado-connect/features/passkey-intelligence). 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.
### 3.3 Comment accéder aux Client Hints via l'API JavaScript (Scripts intégrés)
En utilisant la fonction [navigator.userAgentData.getHighEntropyValues()](https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUAData/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 :
```javascript
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.
## 4. Recommandation pour l'approche actuelle des User-Agents
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) :
| **Navigateur** | **Windows** | **MacOS** | **iOS** | **Android** |
| ---------------- | ----------- | ------------ | --------------- | ---------------- |
| Chrome | ✅ CH | ✅ CH | ❌ (iOS 26+) | ✅ CH |
| Edge | ✅ CH | ✅ CH | ❌ (iOS 26+) | ✅ CH |
| Firefox | ❌ | ❌ | ❌ (iOS 26+) | ❌ |
| Safari | - | ✅ UA-Safari | ❌ (Safari 26+) | - |
| Samsung Internet | - | - | - | ✅ CH |
| WebViews | - | - | ❌ (iOS 26+) | ✅ UA (≥ 16: ❌) |
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](https://web.wurfl.io/) ou [51degrees.com](https://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.
## 5. Comment utiliser les User-Agents et les Client Hints pour les clés d'accès
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](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.
## 6. Conclusion
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.
## Foire Aux Questions
### Comment obtenir la version réelle d'iOS dans mon application web après iOS 26 ?
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.
### Quelle est la différence entre les Client Hints standards et les Critical Client Hints ?
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.
### Pourquoi Apple est-il revenu sur sa décision initiale de 2017 de geler le User-Agent de Safari ?
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.
### Comment puis-je détecter la version de macOS dans Safari si les Client Hints ne sont pas pris en charge ?
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.
### Quelle approche les développeurs de bibliothèques JavaScript doivent-ils utiliser pour la détection multi-navigateurs des appareils ?
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.