---
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-08-28T12:02:15.606Z'
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](https://www.corbado.com/blog/client-hints-user-agent-chrome-safari-firefox) aiutano ad adattarsi a
questa nuova situazione.
Punti chiave che affronteremo:
- **Cos'è la riduzione dell'User-Agent:** comprendere il passaggio verso stringhe
[User-Agent](https://www.corbado.com/blog/client-hints-user-agent-chrome-safari-firefox) ridotte e le sue
implicazioni.
- **Come funzionano i Client Hints:** esplorare i meccanismi alla base dei
[Client Hints](https://www.corbado.com/blog/client-hints-user-agent-chrome-safari-firefox) 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](https://www.corbado.com/it/blog/passkeys-cheat-sheet) 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](https://www.corbado.com/it/blog/passkeys-cheat-sheet) 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](https://www.corbado.com/blog/client-hints-user-agent-chrome-safari-firefox), esploreremo
brevemente la storia
dell'[User-Agent](https://www.corbado.com/blog/client-hints-user-agent-chrome-safari-firefox) e come funzionano i
diversi sforzi di riduzione
dell'[User-Agent](https://www.corbado.com/blog/client-hints-user-agent-chrome-safari-firefox).
### 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](https://www.corbado.com/blog/how-to-enable-passkeys-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](https://www.corbado.com/blog/how-to-enable-passkeys-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](https://www.corbado.com/blog/passkeys-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](https://www.corbado.com/it/blog/parallels-passkeys-cda) 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](https://www.corbado.com/it/blog/parallels-passkeys-cda). 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](https://www.corbado.com/blog/ios-26-passkeys) (rilasciato a settembre 2025), Safari su
[iOS](https://www.corbado.com/blog/how-to-enable-passkeys-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](https://www.corbado.com/blog/ios-26-passkeys):
`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](https://www.corbado.com/blog/ios-26-passkeys), tutti i browser su
[iOS](https://www.corbado.com/blog/how-to-enable-passkeys-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](https://www.corbado.com/blog/passkeys-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](https://www.corbado.com/blog/how-to-enable-passkeys-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](https://www.corbado.com/blog/how-to-enable-passkeys-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](https://www.corbado.com/it/blog/provider-passkey).
- **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](https://www.corbado.com/it/blog/provider-passkey), 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](https://www.corbado.com/it/blog/provider-passkey), 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](https://www.corbado.com/it/blog/passkeys-cheat-sheet) 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](https://www.corbado.com/blog/react-passkeys). 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](https://www.corbado.com/it/blog/parallels-passkeys-cda), utilizziamo
informazioni sul sistema operativo per determinare la probabilità che il client supporti
lo sfruttamento della [CDA](https://www.corbado.com/it/glossary/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](https://www.corbado.com/blog/webauthn-pubkeycredparams-credentialpublickey) 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.