---
url: 'https://www.corbado.com/it/blog/client-hints-user-agent-chrome-safari-firefox'
title: 'Client Hints e User-Agent su Chrome, Safari e Firefox'
description: 'Scopri il supporto delle API User-Agent e Client Hints su Chrome, Safari e Firefox e come li utilizziamo per le passkey e il rilevamento dei dispositivi.'
lang: 'it'
author: 'Vincent Delitz'
date: '2026-07-27T08:24:18.842Z'
lastModified: '2026-07-27T08:25:49.225Z'
keywords: 'riduzione user-agent, user-agent, client hints, api client hints, supporto browser client hints, stringa user agent, client hints chrome'
category: 'Engineering'
---
# Client Hints e User-Agent su Chrome, Safari e Firefox
## Key Facts
- **La riduzione dell'User-Agent** è completa su tutti i principali browser: Chrome ed Edge dal
2023, Firefox parzialmente e Safari bloccato da iOS 26, rilasciato a settembre 2025.
- **Firefox non supporta i Client Hints** o `navigator.userAgentData`, richiedendo
agli sviluppatori di ricorrere alla classica analisi delle stringhe User-Agent sul browser di Mozilla.
- L'API JavaScript **`getHighEntropyValues()`** accede ai dati dei dispositivi ad alta entropia
solo nei browser Chromium. Safari e Firefox non dispongono affatto di questa API.
- La distinzione tra **Windows 10 e Windows 11** è impossibile solo tramite le stringhe User-Agent.
Solo i Client Hints su Chrome ed Edge possono rivelare la versione effettiva della piattaforma.
- Corbado utilizza i Client Hints per la **passkey intelligence**: rilevare nuovi dispositivi e
valutare l'idoneità all'autenticazione cross-device, in particolare per distinguere
le versioni di Windows.
## 1. Introduzione: cosa sono i Client Hints e la riduzione dell'User-Agent?
I metodi per rilevare e rispondere a diversi ambienti utente sono in costante
cambiamento. Tradizionalmente, le **stringhe User-Agent** sono state il modo per identificare le informazioni
sul browser e sul dispositivo, consentendo ai siti web di personalizzare le esperienze di conseguenza. Tuttavia,
queste stringhe sono state spesso utilizzate per il fingerprinting e l'identificazione degli utenti senza il loro
consenso per motivi di marketing, sollevando problemi di privacy.
In questo contesto, sono emersi i **Client Hints come API JavaScript**, fornendo un
modo più controllato e rispettoso della privacy per condividere le informazioni necessarie sul
dispositivo e sulle preferenze dell'utente. Questo articolo si concentra sulle **conseguenze della riduzione
dell'User-Agent** ed esplora come i Client Hints aiutano ad adattarsi a questa nuova situazione.
Punti chiave che affronteremo:
- **Cos'è la riduzione dell'User-Agent:** comprendere il passaggio verso stringhe User-Agent ridotte e le sue implicazioni.
- **Come funzionano i Client Hints:** esplorare i meccanismi alla base dei Client Hints e come possono essere implementati in modo efficace.
Poiché browser e sistemi operativi hanno posizioni diverse e adattano i loro approcci
in modo diverso, gli sviluppatori software affrontano la sfida di garantire che le loro applicazioni possano
ancora rilevare e rispondere in modo accurato a diversi ambienti utente tra browser e
sistemi operativi.
Questo articolo mira a fornire una panoramica completa di questi cambiamenti, offrendo approfondimenti
e indicazioni pratiche per aiutare gli sviluppatori nel caso in cui il loro caso d'uso o software dipenda dai
dettagli del dispositivo o del sistema operativo (ad esempio gestione dettagliata dei dispositivi, rilevamento di dispositivi noti,
prevenzione delle frodi o altri rilevamenti di funzionalità) o, come nel nostro caso, per **ottimizzare
l'esperienza passkey con User-Agent e Client Hints**.
Prima di immergerci nei dettagli tecnici sui Client Hints, esploreremo brevemente la
storia dell'User-Agent e come funzionano i diversi sforzi di riduzione dell'User-Agent.
### 1.1 Una breve storia dell'User-Agent
La storia delle stringhe User-Agent può essere fatta risalire alla nascita dei primi browser
web. Tim Berners-Lee ha sviluppato il primo browser web, WorldWideWeb (in seguito ribattezzato
Nexus) nel 1990. Questo è stato presto seguito da altri browser pionieristici come Line Mode Browser
nel 1991 e, successivamente, sono emersi browser come MidasWWW, ViolaWWW, Erwise e Cello.
Nel 1993, il rilascio di [NCSA Mosaic](https://en.wikipedia.org/wiki/NCSA_Mosaic), spesso
chiamato semplicemente Mosaic, ha il merito di aver innescato l'iniziale ondata di
popolarità del web. La stringa User-Agent di Mosaic era piuttosto semplice, in genere formattata come
`NCSA_Mosaic/1.0` con il nome del prodotto seguito da una barra opzionale e dal numero di versione.
Inizialmente, il **campo User-Agent è stato introdotto per scopi analitici e per aiutare a
identificare i problemi**. È stato esplicitamente raccomandato che questo campo "dovrebbe essere incluso" nelle
richieste HTTP, come notato nell'archivio HTTP del W3C dal 1992. Questo campo semplice
forniva un modo semplice ma efficace per trasmettere il nome e la versione del prodotto, aiutando nella
comprensione e nella risoluzione dei problemi relativi al browser.
Con l'evoluzione del web, è cresciuta anche la complessità e l'utilizzo delle stringhe User-Agent. Sono diventate
più dettagliate e hanno iniziato a includere un patrimonio di informazioni sul browser, sul sistema operativo e sul dispositivo. Sebbene queste informazioni fossero preziose per l'analisi web e l'ottimizzazione delle
esperienze utente, hanno anche posto **significativi problemi di privacy**. Le stringhe User-Agent dettagliate
**consentivano il fingerprinting dei dispositivi**, permettendo a inserzionisti e tracker di creare
profili unici degli utenti e tracciare le loro attività online su diversi siti web.
Nell'era moderna, in cui la privacy è diventata una preoccupazione importante sia per gli utenti che per i regolatori, la natura dettagliata delle stringhe User-Agent è stata sempre più vista come
problematica. Questa consapevolezza ha portato a sforzi per ridurre la granularità delle stringhe User-Agent, con l'obiettivo di trovare un equilibrio tra fornire le informazioni necessarie per la
funzionalità del web e proteggere la privacy degli utenti.
Questa transizione segna l'inizio della **riduzione dell'User-Agent, un movimento verso la
riduzione al minimo delle informazioni condivise nelle stringhe User-Agent per mitigare i rischi per la privacy e
migliorare la sicurezza**.
### 1.2 Riduzione dell'User-Agent e introduzione ai Client Hints
Il movimento verso la riduzione dell'User-Agent è iniziato come risposta alle crescenti preoccupazioni per la privacy.
Ecco una panoramica cronologica delle tappe fondamentali di questa evoluzione:
#### 1.2.1 User-Agent in Safari
Nel 2017, Apple ha avviato il movimento di
[riduzione dell'User-Agent con un famoso post su Twitter](https://x.com/rmondello/status/943545865204989953)
annunciando che Safari avrebbe bloccato la stringa User-Agent in Safari Technology Preview 46
(STP 46), con l'obiettivo di combattere il fingerprinting e migliorare la privacy.
Tuttavia, questa decisione è stata successivamente in parte revocata nel 2021 a causa di significativi
problemi di compatibilità con i siti web che si basavano su informazioni aggiornate dell'User-Agent.
#### 1.2.2 User-Agent in Chrome (+ Edge)
Nel 2019/2020,
[Google ha annunciato piani](https://groups.google.com/a/chromium.org/g/blink-dev/c/-2JIRNMWJ7s/m/u-YzXjZ8BAAJ)
per ridurre la granularità delle stringhe User-Agent in Chrome, introducendo
i [User-Agent Client Hints (UA-CH)](https://chromestatus.com/feature/5704553745874944) come
modo flessibile e controllato per richiedere informazioni specifiche su browser e dispositivi. Google
ha iniziato a testare la riduzione dell'User-Agent nelle versioni Canary e Beta di Chrome, raccogliendo feedback
per garantire compatibilità e funzionalità e l'operazione è stata
[completata nel 2023](https://www.chromium.org/updates/ua-reduction/) per
Android e tutte le altre piattaforme Chrome. Allo
stesso tempo, Chrome **ha introdotto i Client Hints** come nuovo modo per accedere a tali informazioni. Poiché
Microsoft Edge è basato su Chromium, Microsoft Edge si comporta come Chrome su tutte le piattaforme.
#### 1.2.3 User-Agent in Firefox
Nel 2021, Mozilla si è unita allo sforzo, riducendo gradualmente la granularità della stringa User-Agent
ma Mozilla ha deciso di **non supportare i Client Hints in Firefox**.
#### 1.2.4 Gli User-Agent oggi (aggiornato a settembre 2025)
- **La riduzione dell'User-Agent varia in base al browser:** Chromium (Chrome, Edge) ha implementato una completa
riduzione dell'UA con supporto per i Client Hints. Tuttavia, Safari utilizza il proprio approccio UA bloccato
senza adottare UA-CH, e Firefox non ha implementato `navigator.userAgentData`. L'ecosistema
rimane frammentato.
- **I Client Hints si sono evoluti all'interno di Chromium:** tutti i browser inviano ancora un'intestazione User-Agent,
ma nella maggior parte di essi è bloccata a una versione precedente (vedere tabella sotto). Per
Chromium, i Client Hints possono essere utilizzati per ottenere maggiori informazioni.
Diamo un'occhiata a cosa inviano attualmente i browser come User-Agent nel capitolo seguente.
## 2. Cos'è la riduzione dell'User-Agent?
Quando si parla di riduzione dell'User-Agent si intende la **riduzione delle informazioni** all'interno
della stringa User-Agent. Approfondiamo per scoprire cosa era integrato nell'User-Agent
prima della riduzione.
### 2.1 Cos'è un User-Agent classico?
Una stringa User-Agent classica in genere includeva i seguenti componenti, che potevano
essere utilizzati per rilevare funzionalità:
`Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.2.1.0 Mobile Safari/537.36`
- **Sistema operativo:** il nome del sistema operativo (ad esempio Windows, macOS, Linux).
- **Numero di versione del sistema operativo:** la versione specifica del sistema operativo.
- **Nome del browser:** il nome del browser (ad esempio Chrome, Firefox, Safari).
- **Versione del browser:** la versione specifica del browser.
- **Architettura:** l'architettura del sistema (ad esempio x86, ARM).
- **Tipo/Modello di dispositivo:** informazioni sul tipo o modello di dispositivo (ad esempio iPhone, Pixel).
- **Altre informazioni:** questo può includere dettagli aggiuntivi come piattaforma, numero di build, ecc.
#### 2.1.1 Perché utilizzare l'User-Agent per il rilevamento delle funzionalità?
Storicamente, le stringhe User-Agent venivano spesso utilizzate per il rilevamento di funzionalità e piattaforme,
consentendo ai siti web di adattare il proprio contenuto e le proprie funzionalità in base al browser e alle caratteristiche del dispositivo
rilevati (ad esempio determinare quale download offrire per un binario specifico).
Ciò è diventato particolarmente importante con l'ascesa dei telefoni cellulari e dei tablet per i layout
che non erano creati in modo responsive per poter reindirizzare i telefoni cellulari alla loro
versione specifica.
Tuttavia, questo approccio è ora **considerato subottimale, in quanto si basa su presupposti sulle
capacità del browser che potrebbero non essere veri o non essere sufficientemente specifici**. Le moderne pratiche di
sviluppo web raccomandano di utilizzare il **rilevamento delle funzionalità tramite API del browser** ove
possibile per verificare direttamente funzionalità e capacità specifiche del browser. Questo metodo
è più affidabile e garantisce che i siti web funzionino correttamente indipendentemente dalla stringa User-Agent
o dalla versione del browser. Il rilevamento delle funzionalità si concentra sulle capacità effettive del browser,
fornendo un modo più robusto e a prova di futuro per gestire le
differenze di comportamento e funzionalità del browser.
Fino a oggi, ciò non è del tutto possibile in quanto le nuove API del browser per rilevare le funzionalità vengono
implementate in tempi diversi e spesso c'è un approccio diverso tra i team di browser
più grandi (ad esempio i browser basati su Chromium) e quelli più piccoli (ad esempio Firefox).
#### 2.1.2 Comprendere l'entropia nel fingerprinting: perché fornire molte informazioni è un problema?
Maggiori informazioni offrono a un sito web una più ampia possibilità di creare un'impronta digitale con maggiore
"entropia". L'entropia in questo contesto è la quantità di variazione che può essere utilizzata per generare
un'impronta digitale univoca tra i diversi visitatori di un sito web.
Un'impronta digitale può essere utilizzata per scopi diversi. Può essere utilizzata a scopo
protettivo, come il rilevamento delle frodi e l'interruzione delle acquisizioni di account identificando nuovi dispositivi, ma può
anche essere utilizzata per identificare i visitatori senza il loro consenso o per un targeting pubblicitario più specifico.
Nel contesto delle stringhe User-Agent, l'entropia si riferisce alla quantità di informazioni univoche e
identificabili che possono essere utilizzate per tracciare e distinguere i singoli utenti.
- **Informazioni ad alta entropia:** come le versioni specifiche del browser e del sistema operativo, contribuiscono
in modo significativo all'unicità dell'impronta digitale di un utente, rendendo più facile tracciarlo
su diversi siti web.
- **Informazioni a bassa entropia:** nomi generali del browser o nomi del sistema operativo, forniscono
dati meno dettagliati e contribuiscono in misura minore al tracciamento degli utenti poiché un maggior numero di utenti possiede quelle
combinazioni.
Ci sono molte altre informazioni che possono essere utilizzate come fonte di entropia oltre
all'User-Agent. Ad esempio, è possibile trovare diverse fonti di entropia su
[https://coveryourtracks.eff.org](https://coveryourtracks.eff.org).
### 2.2 Riduzione dell'entropia dell'User-Agent
Pertanto, quando i browser parlano di riduzione dell'User-Agent, mirano principalmente a ridurre
le informazioni ad alta entropia. Ecco diversi esempi di riduzione:
#### 2.2.1 Esempio 1: riduzione dell'User-Agent di Chrome
Di seguito, trovi un esempio di riduzione dell'User-Agent di Google Chrome su un
telefono Android:
**Prima:**
`Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.0.0 Mobile Safari/537.36`
**Dopo:**
`Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.0.0 Mobile Safari/537.36`
Il formato dell'User-Agent è rimasto invariato per non interferire con la logica di parsing
esistente delle librerie. Sono stati ridotti i seguenti valori:
- Versione del sistema operativo
- Versione secondaria del browser
- Modello hardware 
L'immagine descrive in dettaglio quali valori continueranno a essere aggiornati in base al sistema operativo
e i valori verdi mostrano quali valori saranno costanti su tutte le piattaforme. Per i diversi
valori del sistema operativo sarà disponibile solo una variante che rimane costante:
| **Sistema operativo** | **Nome ridotto/fisso** |
| -------------------- | --------------------------------- |
| 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 | ridotto (iOS 26+) |
#### 2.2.2 Esempio 2: riduzione dell'User-Agent di Firefox
Di seguito, trovi un esempio di riduzione dell'User-Agent di Mozilla Firefox che
segue la maggior parte delle posizioni di Google sulla riduzione dell'User-Agent.
Ecco un esempio di User-Agent su Windows 11 con un'attuale
versione di Firefox:
`Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0`
In questo User-Agent, l'architettura della CPU, la versione del sistema operativo e la versione
secondaria del browser sono state bloccate.
#### 2.2.3 Esempio 3: riduzione dell'User-Agent di Safari su macOS
Di seguito, trovi un esempio di riduzione dell'User-Agent di Safari su macOS.
Innanzitutto, iniziamo con un **User-Agent Safari su macOS Sonoma versione 14.5** su 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`
Si può notare che la versione di macOS è limitata a `10_15_07` e l'architettura è anch'essa
fissata a `Intel` senza riportare l'architettura della CPU del Mac. Questo vale anche per Firefox e
[Chrome](https://issues.chromium.org/issues/40167872) su macOS.
#### 2.2.4 Esempio 4: User-Agent di Safari su iOS (ora ridotto in iOS 26+)
Prima di iOS 26 (rilasciato a settembre 2025), Safari su
iOS esponeva la versione effettiva del sistema operativo. Tuttavia, **Apple
ha ora bloccato l'User-Agent di iOS/iPadOS** in Safari 26, in modo simile a macOS. L'esempio
di seguito mostra un User-Agent precedente a 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`
**Nota:** a partire da iOS 26, tutti i browser su
iOS (Chrome, Firefox, Safari) hanno ora stringhe User-Agent bloccate,
in modo simile a macOS. Gli esempi seguenti mostrano il comportamento precedente a 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 Limitazioni di rilevamento con la riduzione dell'User-Agent
Nel complesso, è evidente che l'User-Agent è ridotto in modo specifico sulle informazioni
ad alta entropia. La seguente panoramica mostra su quali combinazioni di piattaforme/sistemi
operativi l'User-Agent è ridotto.
| **Browser** | **Windows** | **MacOS** | **iOS** | **Android** |
| ---------------- | ----------- | --------- | ------------------------ | --------------------------- |
| Chrome | ridotto | ridotto | ridotto (iOS 26+) | ridotto |
| Edge | ridotto | ridotto | ridotto (iOS 26+) | ridotto |
| Firefox | ridotto | ridotto | ridotto (iOS 26+) | ridotto |
| Safari | - | ridotto\* | ridotto (Safari 26+)\*\* | - |
| Samsung Internet | - | - | - | ridotto |
| WebViews | - | - | ridotto (iOS 26+) | non ridotto (≥ 16: ridotto) |
Pertanto, i problemi di rilevamento più importanti con un User-Agent ridotto sono (\* = vedi
le note sotto per la versione di macOS):
- **Windows 10 e Windows 11 non possono essere distinti:** non è più possibile distinguere i sistemi
Windows 10 e Windows 11 solo in base all'User-Agent.
- **I dispositivi Android e la versione del sistema operativo non possono essere distinti:** a differenza di
Apple, Android era solito includere il modello hardware effettivo nell'User-Agent. Questo non è più il caso. Pertanto,
modelli hardware diversi non possono più essere distinti solo tramite User-Agent. Con Apple questo non
è mai stato possibile.
- **La versione e l'architettura di macOS non possono essere distinte:** non c'è modo di
differenziare le versioni di macOS e le architetture di piattaforma in base all'User-Agent.
- **(\*) Versione di macOS su Safari:** Safari ha bloccato la versione del sistema operativo ma
continua a mostrare la versione di Safari. Al momento della stesura, per 10.15 e versioni successive, è
sicuro sottrarre tre dalla versione di Safari per rilevare la versione principale di macOS.
- **(\*\*) Versione di iOS su Safari 26+:** a partire da iOS 26 (settembre 2025), Apple ha bloccato
l'User-Agent di iOS/iPadOS, in modo simile a macOS. La versione del sistema operativo non
è più esposta.
Ecco una tabella che mappa le versioni di macOS alle corrispondenti versioni di Safari:
| **Versione di macOS** | **Versione di Safari** | **Anno di rilascio** |
| ---------------------- | ------------------ | ---------------- |
| 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 |
Esistono altri modi per rilevare i sistemi operativi e i browser basati su tecniche di
fingerprinting elaborate, come il fingerprinting TLS. Poiché ci sono scenari legittimi
in cui un rilevamento più profondo del sistema operativo avrebbe senso, Google ha introdotto i Client Hints
per poter ricevere queste informazioni in modo programmatico. Vedremo come funzionano i Client Hints
nel prossimo capitolo.
## 3. Come funzionano i Client Hints?
I Client Hints consentono ai siti web di accedere a informazioni ad alta entropia che sono state rimosse
dalla stringa User-Agent in modo rispettoso della privacy. Esistono due metodi principali per accedere ai
Client Hints:
- **Intestazione HTTP**: l'utilizzo di intestazioni di richiesta HTTP, che è disponibile solo per contesti
di prima parte.
- **API JavaScript**: l'utilizzo di un'API JavaScript, che può essere utilizzata da uno script incorporato.
I Client Hints possono essere utilizzati anche per recuperare le informazioni a bassa entropia che sono già
incluse nell'User-Agent. Ciò implica che su Chrome, dove i Client Hints sono supportati,
gli User-Agent non sono più necessari.
### 3.1 Quali Client Hints esistono?
A seconda del metodo di accesso utilizzato, la denominazione dei Client Hints differisce leggermente.
Abbiamo elencato i nomi più importanti dei Client Hints:
| **Token HTTP UA-CH** | **API JS UA-CH** | **Entropia** |
| -------------------------- | ---------------------------- | ----------- |
| Sec-CH-UA-Platform-Version | UADataValues.platformVersion | Alta |
| Sec-CH-UA-Mobile | NavigatorUAData.mobile | Bassa |
| Sec-CH-UA-Model | UADataValues.model | Alta |
| Sec-CH-UA | NavigatorUAData.brands | Bassa |
| Sec-CH-UA-Arch | UADataValues.architecture | Alta |
### 3.2 Come accedere ai Client Hints tramite intestazioni di richiesta HTTP
In un contesto di prima parte, i siti web possono richiedere informazioni specifiche sul browser e sul
dispositivo dell'utente utilizzando le intestazioni di richiesta HTTP. Questo approccio prevede l'impostazione
dell'intestazione corretta nella risposta HTTP del server, indicando quali Client Hints interessano al
server. Il browser include quindi questi hint nelle richieste successive alla stessa
origine.
Questa intestazione segnala al browser di inviare informazioni dettagliate sull'utente nelle richieste future,
consentendo al server di adattare le risposte di conseguenza. Questo metodo garantisce che le informazioni
dettagliate sull'utente siano accessibili solo al sito web di prima parte, impedendo a risorse di
terze parti di ottenere dati ad alta entropia. Ci sono due tipi di intestazioni di richiesta
disponibili di cui parleremo ora:
- Intestazioni Client Hint normali
- Intestazioni Critical (Client) Hint
#### 3.2.1 Come utilizzare le intestazioni Client Hint normali?
I Client Hints normali sono intestazioni che un server può richiedere dal browser per raccogliere
informazioni sull'ambiente dell'utente **nelle richieste successive**.
**Esempio: Chrome su macOS 14.5 con Client Hints normali su corbado.com**
1. Alla prima richiesta per Corbado.com, Chrome includerà già le seguenti intestazioni a bassa
entropia poiché queste informazioni sono incluse anche nell'User-Agent.
| **Intestazione** | **Valore** |
| ------------------ | ----------------------------------------------------------------- |
| 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. Supponiamo che Corbado.com voglia ricevere la versione del sistema operativo (versione
della piattaforma) nelle **richieste successive.** Pertanto, imposterebbe l'intestazione
"Sec-CH-UA-Platform-Version" appropriata nella risposta alla prima richiesta:
| **Intestazione** | **Valore** |
| ---------- | -------------------------- |
| Accept-CH | Sec-CH-UA-Platform-Version |
3. Nelle **richieste successive**, Corbado.com riceverebbe quindi un'intestazione aggiuntiva con
la versione della piattaforma:
| **Intestazione** | **Valore** |
| ------------------ | ----------------------------------------------------------------- |
| 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" |
Allo stesso tempo, l'User-Agent per questa richiesta rimarrà lo stesso (senza versione
della piattaforma):
`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`
Utilizzando
[https://user-agent-client-hints.glitch.me/headers](https://user-agent-client-hints.glitch.me/headers),
puoi effettivamente provare come apparirebbero i diversi layout di informazioni
per gli hint normali (tieni presente che **devi usare Chrome**). Consulta
[qui](https://github.com/WICG/ua-client-hints) per maggiori dettagli. Nel caso in cui corbado.com
avesse bisogno di queste informazioni nella primissima richiesta di pagina, l'utilizzo dei
Client Hints normali non sarebbe sufficiente, ma c'è un modo per accelerare questo processo con i
Critical (Client) Hints.
#### 3.2.2 Come usare le intestazioni Critical (Client) Hint?
Supponiamo che [corbado.com](https://corbado.com) abbia bisogno della versione della piattaforma nella
prima richiesta per eseguire il rendering di una pagina di download appropriata su misura per l'esatta versione
di macOS. Potrebbe usare i Critical (Client) Hints che porterebbero a un **nuovo tentativo immediato della
richiesta** per renderizzare la pagina includendo l'intestazione solo in quel momento:
**Esempio: Chrome su macOS 14.5 con Critical Client Hints su corbado.com**
1. Alla prima richiesta per corbado.com, Chrome includerà già le seguenti intestazioni a bassa
entropia poiché queste informazioni sono incluse anche nell'User-Agent.
| **Intestazione** | **Valore** |
| ------------------ | ----------------------------------------------------------------- |
| 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. Supponiamo che corbado.com voglia ricevere la versione del sistema operativo (versione della piattaforma)
al **primo rendering della pagina**. Imposterebbe quindi l'intestazione Critical Client Hint
"Sec-CH-UA-Platform-Version" nella risposta alla prima richiesta:
| **Intestazione** | **Valore** |
| ---------- | -------------------------- |
| Accept-CH | Sec-CH-UA-Platform-Version |
3. Chrome non inizierebbe il rendering e riproverebbe immediatamente la richiesta, in modo che **l'intestazione
sia disponibile al primo rendering** di corbado.com. Riceverebbe quindi
l'intestazione aggiuntiva con la versione della piattaforma:
| **Intestazione** | **Valore** |
| -------------------------- | ----------------------------------------------------------------- |
| 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" |
Nei grafici seguenti, **vediamo un altro esempio** in cui il sito web richiede il
modello del dispositivo come parte critica con l'intestazione Critical-CH. Come possiamo vedere, il client ritenta
la richiesta come nell'esempio sopra (diagramma di sequenza a sinistra).
_Client
hints con Chromium:
[https://developers.google.com/privacy-sandbox/protections/User-Agent](https://developers.google.com/privacy-sandbox/protections/User-Agent)_
L'utilizzo di Critical Client Hints aggiunge quindi latenza perché il browser deve avviare immediatamente una seconda
richiesta aggiungendo dei round-trip. C'è un modo per ottimizzare il trasferimento
**facilitando l'handshake TLS** (il riquadro verde nella parte superiore del grafico) per trasmettere già
i dettagli. Questo approccio che facilita
**[ALPN](https://en.wikipedia.org/wiki/Application-Layer_Protocol_Negotiation)
(Application-Layer Protocol Negotiation)** può essere trovato
[qui](https://docs.google.com/document/d/1HQd3vosjFls2jp6DwpkNMUN4CBdmmxZJJz0WhhcqOPw/edit)
in dettaglio ma va oltre lo scopo di questo articolo.
Per ricevere informazioni aggiuntive utilizzando le intestazioni, è necessario aggiungere la configurazione
al backend o ai webserver/load balancer. Questo è facile da fare in un contesto di prima parte,
quando si ha il pieno controllo del sito web come azienda. Ad esempio, i nostri componenti UI
su corbado.com richiedono la versione della piattaforma per aumentare la precisione della nostra
[passkey intelligence](https://docs.corbado.com/corbado-connect/features/passkey-intelligence).
Gli sviluppatori integrano i nostri componenti su varie pagine e richiedere loro di aggiungere intestazioni e
quindi passare tali informazioni ai nostri componenti sarebbe un onere sgradito. Per le SPA e
altre applicazioni JavaScript integrate, c'è un'altra interfaccia che può essere utilizzata, che
verrà spiegata nella sezione successiva.
### 3.3 Come accedere ai Client Hints tramite API JavaScript (Script incorporati)
Utilizzando la funzione
[navigator.userAgentData.getHighEntropyValues()](https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUAData/getHighEntropyValues),
è possibile accedere ai Client Hints anche tramite un'API JavaScript, fornendo un modo flessibile e
dinamico per richiedere informazioni specifiche sul browser e sul dispositivo dell'utente. Questo
metodo prevede l'utilizzo dell'oggetto `navigator.userAgentData` all'interno dello script della pagina web
per interrogare i Client Hints. **Questo metodo non richiede l'impostazione delle intestazioni dei Client Hints,
ma funziona solo nei browser che supportano `navigator.userAgentData` (browser basati su Chromium
come Chrome ed Edge). Firefox e Safari non supportano questa API, quindi gli sviluppatori
devono rilevare le funzionalità e fornire dei fallback.**
Ad esempio, eseguendo questo codice in una Console di Chrome su macOS:
```javascript
if (navigator.userAgentData) {
navigator.userAgentData
.getHighEntropyValues(["architecture", "model", "platformVersion"])
.then((ua) => {
console.log(ua);
});
}
```
Quando la promise si risolve, vengono restituite le informazioni pertinenti. Come abbiamo delineato in precedenza, i
nomi non sono completamente identici alle intestazioni ma sono molto simili.
La `platformVersion` viene quindi restituita nella promise e si può accedere direttamente
dal codice JavaScript incorporato. La copertura per questa funzione è molto inferiore all'effettiva
riduzione dell'User-Agent:
Inoltre, Chrome non offre questa funzionalità su iOS perché utilizza WebKit su
iOS a causa delle limitazioni di Apple.
Ora abbiamo messo insieme i fatti più importanti sulla riduzione dell'User-Agent e su come
i Client Hints offrono una via d'uscita in Chrome.
## 4. Raccomandazione per l'approccio agli User-Agent oggi
A seconda del tuo caso d'uso, dovresti utilizzare un approccio diverso per assicurarti che la tua applicazione
ottenga il miglior risultato possibile:
- **Rilevamento delle funzionalità: usa le API JavaScript del browser esistenti ove possibile**. Ove
fattibile, affidati alle API del browser per rilevare direttamente le funzionalità, anziché utilizzare
l'User-Agent. Questo è più affidabile e a prova di futuro.
- **Per informazioni a bassa entropia, hint come il tipo di dispositivo: l'User-Agent è sufficiente**. Se la tua
applicazione deve solo determinare il tipo di dispositivo o altri dettagli a bassa entropia, la
stringa User-Agent sarà sufficientemente dettagliata. Puoi anche utilizzare API esistenti per
questi scopi.
- **Per informazioni ad alta entropia e controllo del dominio: usa l'approccio dell'intestazione**. Se hai
bisogno di informazioni dettagliate e hai il controllo sul dominio, utilizza l'approccio
dell'intestazione HTTP per richiedere informazioni ad alta entropia dove supportato (Chrome, Edge). Su tutti
gli altri browser (che non inviano intestazioni Client Hint) utilizza il classico User-Agent. Decidi
se è necessario utilizzare Critical Client Hints in base alla necessità o meno delle informazioni
immediatamente o se puoi permetterti un leggero ritardo.
- **Per le librerie JavaScript: usa getHighEntropyValues**. Se stai sviluppando una
libreria JavaScript, l'opzione migliore è utilizzare la funzione
navigator.userAgentData.getHighEntropyValues() per richiedere dinamicamente informazioni specifiche
sul browser e sul dispositivo dell'utente ogni volta che questa funzione è definita e
ricorrere alle librerie di parsing dell'User-Agent in altri casi.
La seguente tabella riassume dove sei ancora in grado di rilevare la versione del sistema operativo
se hai accesso all'User-Agent (UA) e ai Client Hints (CH):
| **Browser** | **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: ❌) |
Scegliendo il metodo appropriato in base alle tue esigenze specifiche, puoi bilanciare efficacemente
la necessità di informazioni dettagliate sugli utenti con considerazioni sulla privacy e sulle prestazioni. Se dipendi in
misura elevata da informazioni difficili da estrarre o che si basano in modo reale sui dispositivi, ricorri a librerie professionali come
[wurfl](https://web.wurfl.io/) o [51degrees.com](https://51degrees.com) che fanno il lavoro pesante per te. Entrambe le librerie supportano l'integrazione di client link nel rilevamento e
hanno anche il proprio modo proprietario per rilevare persino i modelli di iPhone.
## 5. Come usare User-Agent e Client Hints per le passkey
In Corbado, ci concentriamo sullo sviluppo di soluzioni attorno alle passkey utilizzando componenti UI
sviluppati principalmente con React. I nostri componenti sono incorporati in vari
siti web, quindi seguiamo la nostra raccomandazione e utilizziamo getHighEntropyValues() ovunque sia
disponibile, ricorrendo alla classica analisi dell'User-Agent per tutti gli altri casi. Lo usiamo principalmente per:
- **Gestione delle passkey:** sul nostro sito di gestione delle passkey, mostriamo tutte le informazioni
disponibili sul dispositivo in cui è stata creata la passkey.
- **Autenticazione cross-device:** per l'autenticazione cross-device, utilizziamo informazioni
sul sistema operativo per determinare la probabilità che il client supporti lo
sfruttamento della CDA. Questo è particolarmente importante per differenziare tra Windows 10 e
11, cosa possibile solo con i Client Hints su Chrome ed Edge:
_Maggiori
dettagli su:
[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)_
- **Passkey intelligence:** riteniamo che la piattaforma debba decidere se avviare o meno un
accesso con passkey. Pertanto,
integriamo quanta più logica possibile nei nostri componenti per rilevare se viene utilizzato un nuovo dispositivo. In tali scenari, una versione nuova o più piccola del sistema operativo è un indicatore prezioso
del fatto che le cose potrebbero essere cambiate.
Quando abbiamo iniziato a compilare informazioni per i nostri componenti, abbiamo trovato molti dati frammentati
creati durante o prima dell'inizio della riduzione dell'User-Agent. Pertanto, abbiamo pensato che un
riepilogo avrebbe aiutato gli sviluppatori che vogliono migliorare il rilevamento ma non lavorano regolarmente
con User-Agent o Client Hints.
## 6. Conclusione
Dopo che il rilevamento basato su User-Agent è stato lo standard per decenni, le stringhe User-Agent sono
diventate meno dettagliate per proteggere la privacy degli utenti.
In questo articolo abbiamo trattato:
- **Cos'è la riduzione dell'User-Agent?** La riduzione dell'User-Agent è il processo di minimizzazione
della quantità di informazioni condivise tramite le stringhe User-Agent per proteggere
la privacy degli utenti. Questa transizione riduce la
granularità dei dati come la versione del sistema operativo e il modello hardware, che venivano
precedentemente utilizzati per il fingerprinting e il tracciamento degli utenti su diversi siti web. Abbiamo
esplorato l'impatto di questa riduzione sugli sviluppatori e come possono adattarsi a questi cambiamenti.
- **Come funzionano i Client Hints?** I Client Hints forniscono un meccanismo per richiedere informazioni
specifiche ad alta entropia sul dispositivo dell'utente in un modo più attento alla privacy.
Utilizzando intestazioni HTTP e API JavaScript, gli sviluppatori possono accedere a dati dettagliati
sull'ambiente dell'utente quando necessario. Abbiamo discusso come sono implementati i Client Hints, i
tipi di hint disponibili e i metodi per accedervi tramite intestazioni di richiesta HTTP e
JavaScript.
I Client Hints continuano a evolversi e la loro adozione potrebbe aumentare man mano che più browser
e sviluppatori ne riconoscono i vantaggi. Tuttavia, resta da vedere se il loro
supporto si diffonderà in modo capillare o se il web continuerà a divergere su questo argomento.
## Domande frequenti
### Come posso ottenere la versione effettiva di iOS nella mia app web dopo iOS 26?
Apple ha bloccato la stringa User-Agent di iOS/iPadOS in Safari 26, rilasciato a settembre 2025,
il che significa che la versione del sistema operativo non è più esposta tramite User-Agent su nessun browser in esecuzione su iOS.
A differenza di Chrome su Android o desktop, su iOS non è disponibile alcuna API Client Hints, quindi la
versione effettiva di iOS non è più accessibile in modo programmatico.
### Qual è la differenza tra i Client Hints normali e i Critical Client Hints?
I Client Hints normali, richiesti tramite l'intestazione di risposta `Accept-CH`, vengono inclusi solo
nelle richieste successive e non sono disponibili al caricamento iniziale della pagina. I Critical Client Hints
attivano un nuovo tentativo immediato del browser prima del rendering, garantendo che l'hint sia disponibile al
primo rendering, ma questo aggiunge un round-trip di latenza al ciclo di richiesta.
### Perché Apple ha revocato la sua decisione iniziale del 2017 di bloccare l'User-Agent di Safari?
Apple ha annunciato il blocco dell'User-Agent in Safari Technology Preview 46 nel 2017, ma ha
parzialmente revocato la decisione nel 2021 a causa di significativi problemi di compatibilità con i
siti web che si basavano su informazioni aggiornate dell'User-Agent. Apple ha successivamente implementato
un approccio di blocco più graduale dell'UA invece di un blocco completo immediato in quel momento.
### Come posso rilevare la versione di macOS in Safari se i Client Hints non sono supportati?
Safari non supporta i Client Hints, ma la versione di macOS può essere dedotta dal numero di
versione di Safari nella stringa User-Agent. Sottraendo tre dalla versione principale di Safari
si ottiene in modo affidabile la versione principale di macOS per macOS 10.15 e versioni successive, in base al
costante allineamento delle versioni tra Safari e macOS.
### Quale approccio dovrebbero utilizzare gli sviluppatori di librerie JavaScript per il rilevamento dei dispositivi cross-browser?
L'approccio consigliato è chiamare `navigator.userAgentData.getHighEntropyValues()` quando
la funzione è definita, coprendo i browser basati su Chromium, e utilizzare librerie di
analisi delle stringhe User-Agent come fallback per Firefox e Safari. Nei casi che richiedono
un'identificazione molto specifica del modello di dispositivo, librerie professionali come wurfl o 51degrees offrono
funzionalità di rilevamento aggiuntive oltre a quelle esposte dalle stringhe User-Agent.