Client Hints e User-Agents no Chrome, Safari e Firefox

Cheatsheet de Passkeys. Guias práticos, padrões de implementação e KPIs para programas de passkeys.

Obter cheat sheet

Os métodos para detectar e responder a diferentes ambientes de usuário estão em constante mudança. Tradicionalmente, as strings de User-Agent têm sido a forma de identificar informações de navegador e dispositivo, permitindo que os sites adaptem as experiências de acordo. No entanto, essas strings muitas vezes têm sido usadas para fingerprinting e identificação de usuários sem o seu consentimento por motivos de marketing, levantando preocupações de privacidade.

Nesse contexto, Client Hints como APIs JavaScript surgiram como uma ferramenta, fornecendo uma maneira mais controlada e que respeita a privacidade de compartilhar informações necessárias sobre o dispositivo e as preferências do usuário. Este artigo concentra-se nas consequências da redução do User-Agent e explora como Client Hints ajudam a se adaptar a essa nova situação.

Pontos principais que abordaremos:

• O que é a redução do User-Agent: Entendendo a mudança em direção a strings de User-Agent reduzidas e suas implicações.
• Como funcionam os Client Hints: Explorando os mecanismos por trás dos Client Hints e como eles podem ser implementados de forma eficaz.

Como navegadores e sistemas operacionais têm posições diferentes e adaptam suas abordagens de forma diferente, os desenvolvedores de software enfrentam o desafio de garantir que seus aplicativos ainda possam detectar e responder com precisão a ambientes de usuário variados em diferentes navegadores e sistemas operacionais.

Este artigo visa fornecer uma visão abrangente dessas mudanças, oferecendo insights e orientações práticas para ajudar os desenvolvedores caso seu caso de uso ou software dependa de detalhes do dispositivo ou de sistemas operacionais (por exemplo, gerenciamento detalhado de dispositivos, detecção de dispositivos conhecidos, prevenção de fraudes ou outras detecções de recursos) ou, como no nosso próprio caso, otimizar a experiência de chaves de acesso com User-Agent e Client Hints.

Antes de mergulharmos nos detalhes técnicos sobre Client Hints, exploraremos brevemente a história do User-Agent e como funcionam os diferentes esforços de redução do User-Agent.

A história das strings de User-Agent remonta ao início dos primeiros navegadores da web. Tim Berners-Lee desenvolveu o primeiro navegador da web, WorldWideWeb (mais tarde renomeado para Nexus) em 1990. Este foi logo seguido por outros navegadores pioneiros como o Line Mode Browser em 1991 e, subsequentemente, surgiram navegadores como MidasWWW, ViolaWWW, Erwise e Cello.

Em 1993, o lançamento do NCSA Mosaic, muitas vezes referido simplesmente como Mosaic, é creditado por iniciar o primeiro aumento na popularidade da web. A string do User-Agent do Mosaic era bastante direta, tipicamente formatada como NCSA_Mosaic/1.0, apresentando o nome do produto seguido por uma barra opcional e o número da versão.

Inicialmente, o campo User-Agent foi introduzido para fins analíticos e para ajudar a identificar problemas. Foi explicitamente recomendado que este campo "deveria ser incluído" em requisições HTTP, conforme observado no arquivo HTTP do W3C de 1992. Esse campo direto fornecia uma maneira simples, mas eficaz, de transmitir o nome do produto e a versão, auxiliando na compreensão e resolução de problemas relacionados ao navegador.

À medida que a web evoluiu, a complexidade e o uso de strings de User-Agent também evoluíram. Elas tornaram-se mais detalhadas e começaram a incluir uma riqueza de informações sobre o navegador, sistema operacional e dispositivo. Embora essas informações fossem valiosas para análises da web e para a otimização de experiências do usuário, elas também representavam preocupações significativas de privacidade. Strings de User-Agent detalhadas permitiam o fingerprinting do dispositivo, possibilitando que anunciantes e rastreadores criassem perfis únicos de usuários e rastreassem suas atividades online em diferentes sites.

Na era moderna, onde a privacidade tornou-se uma preocupação importante para usuários e reguladores, a natureza detalhada das strings de User-Agent passou a ser cada vez mais vista como problemática. Essa percepção levou a esforços para reduzir a granularidade das strings de User-Agent, com o objetivo de encontrar um equilíbrio entre fornecer as informações necessárias para a funcionalidade da web e proteger a privacidade do usuário. Essa transição marca o início da redução do User-Agent, um movimento no sentido de minimizar as informações compartilhadas em strings de User-Agent para mitigar riscos de privacidade e aprimorar a segurança.

O movimento em direção à redução do User-Agent começou como uma resposta às crescentes preocupações com a privacidade. Aqui está uma visão geral cronológica dos principais marcos nessa evolução:

Em 2017, a Apple iniciou o movimento de redução do User-Agent com uma famosa postagem no Twitter anunciando que o Safari congelaria a string do User-Agent no Safari Technology Preview 46 (STP 46), com o objetivo de combater o fingerprinting e melhorar a privacidade.

No entanto, essa decisão foi posteriormente revertida de forma parcial em 2021 devido a problemas significativos de compatibilidade com sites que dependiam de informações atualizadas de User-Agent.

Em 2019/2020, o Google anunciou planos para reduzir a granularidade das strings de User-Agent no Chrome, introduzindo User-Agent Client Hints (UA-CH) como uma forma flexível e controlada de solicitar informações específicas sobre navegadores e dispositivos. O Google começou a testar a redução do User-Agent nas versões Canary e Beta do Chrome, coletando feedback para garantir compatibilidade e funcionalidade, o que foi concluído em 2023 para Android e todas as outras plataformas do Chrome. Ao mesmo tempo, o Chrome introduziu Client Hints como uma nova maneira de acessar essas informações. Como o Microsoft Edge é baseado no Chromium, ele se comporta como o Chrome em todas as plataformas.

Em 2021, a Mozilla juntou-se ao esforço, reduzindo gradualmente a granularidade da string do User-Agent, mas a Mozilla decidiu não suportar Client Hints no Firefox.

• A redução do User-Agent varia de acordo com o navegador: O Chromium (Chrome, Edge) implementou redução completa de UA com suporte a Client Hints. No entanto, o Safari usa a sua própria abordagem de UA congelado sem adotar UA-CH, e o Firefox não implementou navigator.userAgentData. O ecossistema continua fragmentado.

• Os Client Hints evoluíram dentro do Chromium: Todos os navegadores ainda enviam um cabeçalho User-Agent, mas na maioria deles ele está congelado em uma versão mais antiga (veja a tabela abaixo). Para o Chromium, os Client Hints podem ser usados para obter mais informações.

Vejamos o que os navegadores enviam atualmente como User-Agents no próximo capítulo.

Assine nosso Substack de passkeys para receber as últimas novidades.

Assinar

Quando se fala sobre redução do User-Agent, o que se entende é reduzir as informações na string do User-Agent. Vamos aprofundar para descobrir o que estava incorporado no User-Agent antes da redução.

Uma string de User-Agent clássica tipicamente incluía os seguintes componentes, que podiam ser usados para detectar funcionalidades:

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

• Sistema operacional: O nome do sistema operacional (por exemplo, Windows, macOS, Linux).
• Número da versão do sistema operacional: A versão específica do sistema operacional.
• Nome do navegador: O nome do navegador (por exemplo, Chrome, Firefox, Safari).
• Versão do navegador: A versão específica do navegador.
• Arquitetura: A arquitetura do sistema (por exemplo, x86, ARM).
• Tipo/Modelo do dispositivo: Informações sobre o tipo ou modelo do dispositivo (por exemplo, iPhone, Pixel).
• Outras informações: Isso pode incluir detalhes adicionais como plataforma, número de compilação, etc.

Historicamente, as strings de User-Agent eram muitas vezes usadas para detecção de recursos e plataforma, permitindo que os sites adaptassem seu conteúdo e funcionalidade com base nas características detectadas do navegador e do dispositivo (por exemplo, determinar qual download para binário específico oferecer). Isso tornou-se especialmente importante com o surgimento de telefones celulares e tablets para layouts que não foram criados de forma responsiva para poder redirecionar telefones celulares para a sua versão específica.

No entanto, essa abordagem agora é considerada subótima, pois se baseia em suposições sobre os recursos do navegador que podem não ser verdadeiras ou não serem suficientemente específicas. Práticas modernas de desenvolvimento web defendem o uso de detecção de recursos através de APIs de navegador sempre que possível, para verificar diretamente recursos e capacidades específicos do navegador. Esse método é mais confiável e garante que os sites funcionem corretamente, independentemente da string do User-Agent ou da versão do navegador. A detecção de recursos foca-se nas capacidades reais do navegador, fornecendo uma maneira mais robusta e preparada para o futuro para lidar com diferenças no comportamento e na funcionalidade do navegador.

Até hoje, isso não é totalmente possível, pois novas APIs de navegador para detectar funcionalidades são implementadas em diferentes momentos e muitas vezes há uma abordagem diferente entre as equipes de navegadores maiores (por exemplo, navegadores baseados em Chromium) e menores (por exemplo, Firefox).

Mais informações dão a um site uma possibilidade maior de criar um fingerprint com mais "entropia". Entropia neste contexto é a quantidade de variação que pode ser usada para gerar um fingerprint único entre diferentes visitantes de um site.

Um fingerprint pode ser usado para propósitos diferentes. Pode ser usado para propósitos de proteção, como detectar fraudes e interromper invasões de contas identificando novos dispositivos, mas também pode ser usado para identificar visitantes sem o consentimento deles ou para um direcionamento de anúncios mais específico.

No contexto das strings de User-Agent, entropia refere-se à quantidade de informações únicas e identificáveis que podem ser usadas para rastrear e distinguir usuários individuais.

• Informações de alta entropia: Como versões específicas de navegador e SO, contribuem de forma significativa para a singularidade do fingerprint de um usuário, facilitando o seu rastreamento em diferentes sites.
• Informações de baixa entropia: Nomes gerais de navegador ou de sistema operacional fornecem dados menos detalhados e contribuem menos para o rastreamento do usuário, pois mais usuários compartilham essas combinações.

Há muitas outras informações que podem ser usadas como fonte de entropia além do User-Agent. Por exemplo, você pode encontrar diferentes fontes de entropia em https://coveryourtracks.eff.org.

Portanto, quando os navegadores falam sobre a redução do User-Agent, visam principalmente reduzir as informações de alta entropia. Aqui estão diferentes exemplos para a redução:

A seguir, você encontra um exemplo da redução do User-Agent do Google Chrome em um telefone Android:

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

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

O formato do User-Agent permaneceu inalterado para não interferir na lógica de análise existente das bibliotecas. Os seguintes valores foram reduzidos:

• Versão do sistema operacional
• Versão secundária do navegador
• Modelo de hardware
  

O gráfico detalha quais valores continuarão a ser atualizados com base no sistema operacional e os valores em verde mostram quais valores serão constantes em todas as plataformas. Para diferentes valores de sistema operacional, haverá apenas uma variante disponível que permanece constante:

A seguir, você encontra um exemplo de redução do User-Agent do Mozilla Firefox, que segue a maior parte das posições do Google sobre a redução do User-Agent.

Aqui está um exemplo de um User-Agent no Windows 11 com uma versão atual do Firefox:

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

Neste User-Agent, a arquitetura da CPU, a versão do sistema operacional e a versão secundária do navegador foram congeladas.

A seguir, você encontra um exemplo de redução de User-Agent do Safari no macOS.

Primeiro, vamos começar com um User-Agent do Safari num macOS Sonoma Versão 14.5 em 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

Pode-se ver que a versão do macOS está limitada a 10_15_07 e a arquitetura também está fixada em Intel, não relatando a arquitetura da CPU do Mac. Isso também é verdadeiro para o Firefox e o Chrome no macOS.

Antes do iOS 26 (lançado em setembro de 2025), o Safari no iOS expunha a versão real do sistema operacional. No entanto, a Apple agora congelou o User-Agent do iOS/iPadOS no Safari 26, semelhante ao macOS. O exemplo abaixo mostra um User-Agent pré-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 partir do iOS 26, todos os navegadores no iOS (Chrome, Firefox, Safari) agora têm strings de User-Agent congeladas, de forma semelhante ao macOS. Os exemplos abaixo mostram o comportamento pré-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

No geral, é óbvio que o User-Agent é reduzido de forma específica nas informações de alta entropia. A visão geral a seguir mostra em quais combinações de plataforma/sistema operacional o User-Agent é reduzido.

Portanto, os problemas de detecção mais importantes com um User-Agent reduzido são (* = veja os comentários abaixo para a versão do macOS):

• O Windows 10 e o Windows 11 não podem ser distinguidos: Você não pode mais distinguir os sistemas Windows 10 e Windows 11 apenas com base no User-Agent.
• Os dispositivos Android e a versão do sistema operacional não podem ser distinguidos: Em contraste com a Apple, o Android costumava incluir o modelo real de hardware no User-Agent. Isso já não é o caso. Portanto, diferentes modelos de hardware não podem mais ser distinguidos apenas pelo User-Agent. Com a Apple, isso nunca foi possível.
• A versão do macOS e a arquitetura não podem ser distinguidas: Não há como diferenciar versões do macOS e arquiteturas de plataforma com base no User-Agent.
• (*) Versão do macOS no Safari: O Safari congelou a versão do sistema operacional, mas continua a mostrar a versão do Safari. No momento da redação, para 10.15 e superior, é seguro subtrair três da versão do Safari para detectar a versão principal do macOS.
• (**) Versão do iOS no Safari 26+: A partir do iOS 26 (setembro de 2025), a Apple congelou o User-Agent do iOS/iPadOS, da mesma forma que o macOS. A versão do sistema operacional já não é exposta.

Aqui está uma tabela mapeando as versões do macOS para as suas versões correspondentes do Safari:

Existem outras formas de detectar sistemas operacionais e navegadores com base em técnicas de fingerprinting elaboradas, como o fingerprinting de TLS. Como existem cenários legítimos onde uma detecção mais aprofundada do sistema operacional faria sentido, o Google introduziu Client Hints para conseguir receber essas informações programaticamente. Veremos como os Client Hints funcionam no próximo capítulo.

Client Hints permitem que os sites acessem informações de alta entropia que foram removidas da string do User-Agent de uma maneira amigável à privacidade. Existem dois métodos principais para acessar Client Hints:

• Cabeçalho HTTP: Usando cabeçalhos de requisição HTTP, o que está disponível apenas para contextos primários (first-party).
• API JavaScript: Usando uma API JavaScript, que pode ser usada por um script incorporado.

Os Client Hints também podem ser usados para recuperar as informações de baixa entropia que já estão incluídas no User-Agent. Isso implica que, no Chrome, onde os Client Hints são suportados, os User-Agents não são mais necessários.

Dependendo de qual método de acesso é usado, a nomenclatura dos Client Hints varia ligeiramente. Listamos os nomes mais importantes dos Client Hints:

Em um contexto primário, os sites podem solicitar informações específicas sobre o navegador e o dispositivo do usuário usando cabeçalhos de requisição HTTP. Essa abordagem envolve configurar o cabeçalho correto na resposta HTTP do servidor, indicando em quais Client Hints o servidor está interessado. O navegador inclui, então, essas dicas nas solicitações subsequentes para a mesma origem.

Esse cabeçalho sinaliza para o navegador enviar informações detalhadas do usuário em solicitações futuras, permitindo que o servidor adapte as respostas de acordo. Esse método garante que as informações detalhadas do usuário sejam acessíveis apenas para o site original, evitando que recursos de terceiros obtenham dados de alta entropia. Há dois tipos de cabeçalhos de requisição disponíveis, que discutiremos agora:

• Cabeçalhos de Client Hints Regulares
• Cabeçalhos de Client Hints Críticos

Client Hints regulares são cabeçalhos que um servidor pode solicitar do navegador para coletar informações sobre o ambiente do usuário em solicitações subsequentes.

Exemplo: Chrome no macOS 14.5 com Client Hints regulares no corbado.com

1. Na primeira solicitação para o Corbado.com, o Chrome já incluirá os seguintes cabeçalhos de baixa entropia, pois essas informações também estão incluídas no User-Agent.

2. Digamos que o Corbado.com gostaria de receber a versão do sistema operacional (platform version) em solicitações subsequentes. Portanto, ele definiria o cabeçalho apropriado “Sec-CH-UA-Platform-Version” na resposta à primeira solicitação:

3. Em solicitações subsequentes, o Corbado.com receberia um cabeçalho adicional com a versão da plataforma:

Ao mesmo tempo, o User-Agent para essa solicitação permanecerá o mesmo (sem a versão da plataforma):

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

Usando https://user-agent-client-hints.glitch.me/headers, você pode brincar de ver como diferentes layouts de informações se pareceriam para Client Hints regulares (lembre-se de que você deve usar o Chrome). Veja aqui para mais detalhes. Caso o corbado.com precisasse dessas informações logo na primeira solicitação da página, usar Client Hints regulares não seria suficiente, mas há uma forma de acelerar esse processo com Client Hints críticos.

Digamos que o corbado.com precise da versão da plataforma na primeira solicitação para renderizar uma página de download apropriada adaptada à versão exata do macOS. Poderia usar os Client Hints críticos que levariam a uma nova tentativa imediata da solicitação para renderizar apenas a página incluindo o cabeçalho:

Exemplo: Chrome no macOS 14.5 com Client Hints críticos no corbado.com

1. Na primeira solicitação para o corbado.com, o Chrome já incluirá os seguintes cabeçalhos de baixa entropia, pois essas informações também estão incluídas no User-Agent.

2. Digamos que o corbado.com gostaria de receber a versão do sistema operacional (versão da plataforma) na primeira renderização da página. Ele definiria o cabeçalho crítico “Sec-CH-UA-Platform-Version” na resposta à primeira solicitação:

3. O Chrome não iniciaria a renderização e tentaria novamente a solicitação imediatamente, para que o cabeçalho estivesse disponível na primeira renderização do corbado.com. Receberia, então, o cabeçalho adicional com a versão da plataforma:

Nos gráficos a seguir, vemos outro exemplo onde o site solicita o modelo do dispositivo como uma parte crítica com o cabeçalho Critical-CH. Como podemos ver, o cliente tenta a solicitação novamente como no exemplo acima (gráfico de sequência à esquerda).

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

Usar Client Hints críticos, portanto, adiciona latência porque o navegador deve iniciar uma segunda solicitação imediatamente, adicionando tempo de ida e volta. Existe uma maneira de otimizar a transferência facilitando o handshake TLS (a caixa verde no topo do gráfico) para já transmitir os detalhes. Esta abordagem facilitando a ALPN (Application-Layer Protocol Negotiation) pode ser encontrada em detalhes aqui, mas está além do escopo deste artigo.

Para receber informações adicionais usando cabeçalhos, a configuração precisa ser adicionada no backend ou no servidor web/balanceadores de carga. Isso é feito de forma fácil num contexto primário, quando você tem controle total sobre o site como empresa. Por exemplo, os nossos componentes de interface no corbado.com exigem a versão da plataforma para aumentar a precisão da nossa inteligência de chaves de acesso. Os desenvolvedores integram os nossos componentes em várias páginas e exigir que eles adicionem cabeçalhos e passem essas informações para os nossos componentes seria uma sobrecarga desagradável. Para SPAs e outros aplicativos JavaScript integrados, há outra interface que pode ser usada, que será explicada na próxima seção.

Usando a função navigator.userAgentData.getHighEntropyValues(), Client Hints também podem ser acessados através de uma API JavaScript, fornecendo uma maneira flexível e dinâmica de solicitar informações específicas sobre o navegador e o dispositivo do usuário. Esse método envolve usar o objeto navigator.userAgentData no script da página da web para consultar os Client Hints. Esse método não exige que os cabeçalhos de Client Hints sejam configurados, mas só funciona em navegadores que suportam navigator.userAgentData (navegadores baseados em Chromium como Chrome e Edge). Firefox e Safari não suportam esta API, então os desenvolvedores devem detectar os recursos e fornecer alternativas (fallbacks).

Por exemplo, ao executar este código em um console do Chrome no macOS:

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

Quando a promise é resolvida, as informações relevantes são devolvidas. Como descrevemos acima, os nomes não são totalmente idênticos aos dos cabeçalhos, mas são muito parecidos.

A platformVersion é então devolvida na promise e pode ser acessada diretamente do código JavaScript integrado. A cobertura para essa função é muito menor do que a redução real do User-Agent:

Além disso, o Chrome não oferece essa funcionalidade no iOS porque usa o WebKit no iOS devido às limitações da Apple.

Reunimos agora os factos mais importantes sobre a redução do User-Agent e como os Client Hints oferecem uma forma de contorná-la no Chrome.

Dependendo do seu caso de uso, você deve usar uma abordagem diferente para garantir que o seu aplicativo obtenha o melhor resultado possível:

• Detecção de recursos: Use APIs JavaScript de navegador existentes sempre que possível. Sempre que for viável, confie nas APIs do navegador para detectar funcionalidades diretamente, em vez de usar o User-Agent. Isso é mais confiável e à prova do futuro.
• Para informações de baixa entropia, como o tipo de dispositivo: O User-Agent é suficiente. Se a sua aplicação só precisar determinar o tipo de dispositivo ou outros detalhes de baixa entropia, a string do User-Agent será suficientemente detalhada. Também pode usar APIs existentes para esses fins.
• Para informações de alta entropia e controlo de domínio: Use a abordagem de cabeçalho. Se você exigir informações detalhadas e tiver controlo sobre o domínio, utilize a abordagem de cabeçalho HTTP para solicitar informações de alta entropia onde forem suportadas (Chrome, Edge). Em todos os outros navegadores (que não enviam cabeçalhos Client Hint), use o User-Agent clássico. Decida se precisa de usar Client Hints críticos com base no facto de precisar das informações imediatamente ou se pode suportar um ligeiro atraso.
• Para bibliotecas JavaScript: Use getHighEntropyValues. Se você estiver desenvolvendo uma biblioteca JavaScript, a melhor opção é usar a função navigator.userAgentData.getHighEntropyValues() para solicitar de forma dinâmica informações específicas sobre o navegador e o dispositivo do usuário sempre que essa função estiver definida e recorrer a bibliotecas de análise de User-Agent noutros casos.

A tabela a seguir resume onde você ainda é capaz de detectar a versão do sistema operacional se tiver acesso ao User-Agent (UA) e aos Client Hints (CH):

Ao escolher o método apropriado com base nas suas necessidades específicas, você pode equilibrar de forma eficaz a necessidade de informações detalhadas sobre os usuários com considerações de privacidade e desempenho. Se você depender fortemente de informações que são difíceis de extrair ou são baseadas no dispositivo, recorra a bibliotecas profissionais como wurfl ou 51degrees.com que fazem o trabalho pesado por si. Ambas as bibliotecas suportam a integração de Client Hints na deteção e também têm a sua própria forma proprietária de detetar até modelos de iPhone.

No Corbado, focamo-nos no desenvolvimento de soluções em torno de chaves de acesso (passkeys) utilizando componentes de interface desenvolvidos principalmente em React. Os nossos componentes são incorporados em vários sites, portanto, seguimos a nossa própria recomendação e usamos getHighEntropyValues() sempre que estiver disponível, recorrendo à análise clássica do User-Agent para todos os outros casos. Usamos isto principalmente para:

• Gestão de chaves de acesso: No nosso site de gestão de chaves de acesso, exibimos todas as informações disponíveis sobre o dispositivo em que a chave de acesso foi criada.
• Autenticação entre dispositivos: Para autenticação entre dispositivos, usamos informações sobre o sistema operacional para determinar a probabilidade do cliente suportar o aproveitamento de CDA. Isto é especialmente importante ao diferenciar entre Windows 10 e 11, o que só é possível com Client Hints no Chrome e no Edge:

Mais detalhes em: https://learn.microsoft.com/en-us/microsoft-edge/web-platform/how-to-detect-win11

• Inteligência de chaves de acesso: Acreditamos que a plataforma deve decidir se um login por chave de acesso deve ser iniciado. Portanto, integramos o máximo de lógica possível nos nossos componentes para detetar se um novo dispositivo está a ser utilizado. Nesses cenários, uma versão de sistema operacional nova ou mais pequena é um indício valioso de que as coisas podem ter mudado.

Quando começámos a compilar informações para os nossos componentes, encontrámos muitos dados fragmentados criados durante ou antes do início da redução do User-Agent. Portanto, pensámos que um resumo ajudaria os desenvolvedores que pretendem melhorar a deteção, mas não trabalham com User-Agents ou Client Hints regularmente.

Após a deteção baseada em User-Agent ter sido o padrão por décadas, as strings de User-Agent tornaram-se menos detalhadas para proteger a privacidade dos usuários. Neste artigo abordámos:

• O que é a redução do User-Agent? A redução do User-Agent é o processo de minimizar a quantidade de informações partilhadas através das strings do User-Agent para proteger a privacidade dos usuários. Esta transição reduz a granularidade de dados como a versão do sistema operacional e o modelo de hardware, que eram usados anteriormente para fingerprinting e rastreamento de usuários em vários sites. Explorámos como essa redução afeta os desenvolvedores e como eles podem adaptar-se a essas mudanças.
• Como funcionam os Client Hints? Os Client Hints fornecem um mecanismo para solicitar informações de alta entropia específicas sobre o dispositivo do usuário de uma forma mais consciente em termos de privacidade. Ao usar cabeçalhos HTTP e APIs JavaScript, os desenvolvedores podem aceder a dados detalhados sobre o ambiente do usuário quando necessário. Discutimos como os Client Hints são implementados, os tipos de hints disponíveis e os métodos para aceder a eles através de cabeçalhos de solicitação HTTP e JavaScript.

Os Client Hints continuam a evoluir e a sua adoção pode aumentar à medida que mais navegadores e desenvolvedores reconhecem os seus benefícios. No entanto, resta saber se o seu suporte se tornará generalizado ou se a web continuará a divergir sobre este tópico.

Sobre a Corbado

Corbado é a Authentication Intelligence Platform para times de CIAM que rodam autenticação consumer em escala. Mostramos o que logs de IDP e ferramentas genéricas de analytics não enxergam: quais dispositivos, versões de SO, navegadores e gerenciadores de credenciais suportam passkeys, por que os registros não viram logins, onde o fluxo WebAuthn falha e quando uma atualização de SO ou navegador quebra silenciosamente o login — tudo sem substituir Okta, Auth0, Ping, Cognito ou seu IDP interno. Dois produtos: Corbado Observe adiciona observabilidade para passkeys e qualquer outro método de login. Corbado Connect entrega passkeys gerenciados com analytics integrado (junto ao seu IDP). VicRoads roda passkeys para mais de 5M de usuários com Corbado (+80% de ativação de passkey). Fale com um especialista em Passkeys →

A Apple congelou a string do User-Agent do iOS/iPadOS no Safari 26, lançado em setembro de 2025, o que significa que a versão do sistema operacional já não é exposta por via do User-Agent em nenhum navegador em execução no iOS. Diferentemente do Chrome no Android ou desktop, nenhuma API de Client Hints está disponível nos navegadores iOS, portanto, a versão real do iOS não é mais acessível de forma programática.

Os Client Hints regulares, solicitados via cabeçalho de resposta Accept-CH, são incluídos apenas nas solicitações subsequentes e não estão disponíveis no carregamento inicial da página. Os Client Hints críticos disparam uma repetição imediata do navegador antes da renderização, garantindo que o hint esteja disponível na primeira renderização, mas isso adiciona um tempo de latência ao ciclo de solicitação.

A Apple anunciou o congelamento do User-Agent no Safari Technology Preview 46 em 2017, mas reverteu a decisão em parte em 2021 devido a problemas significativos de compatibilidade com sites que dependiam de informações de User-Agent atualizadas. A Apple implementou depois uma abordagem gradual de congelamento da UA em vez de um congelamento completo imediato naquele momento.

O Safari não suporta Client Hints, mas a versão do macOS pode ser inferida pelo número da versão do Safari na string do User-Agent. A subtração de três da versão principal do Safari mapeia de forma fiável a versão principal do macOS no macOS 10.15 e superior, com base no alinhamento consistente de lançamentos entre o Safari e as versões do macOS.

A abordagem recomendada é chamar navigator.userAgentData.getHighEntropyValues() quando a função está definida, abrangendo navegadores baseados em Chromium, e recorrer a bibliotecas de análise de string de User-Agent para o Firefox e Safari. Para casos que exigem a identificação altamente específica do modelo do dispositivo, bibliotecas profissionais como o wurfl ou o 51degrees fornecem recursos de deteção adicionais para além do que as strings de User-Agent expõem.