---
title: "O que é User-Agent? Como ver e como alterar"
description: "User-Agent é a linha de identidade que o navegador envia em cada requisição. Como ler, como alterar no Chrome e no Android e o que mudou com os Client Hints."
url: https://proxynet.io/pt-br/blog/what-is-user-agent
date: 2026-09-19
author: "Acar Diveroli"
category: "Proxy 101, Tutoriais"
lang: pt-BR
---

# O que é User-Agent? Como ver e como alterar

Quando você abre a página de download de um programa, o site sugere sozinho o arquivo certo para o seu sistema operacional. Alguns sites enviam uma página móvel separada para quem chega pelo celular. O site faz isso sem perguntar nada, porque o navegador envia, junto com cada requisição, um texto de uma linha em que se apresenta. Essa linha se chama User-Agent (em português, "agente do usuário").

A primeira metade deste artigo é para todo mundo: como ler uma string de User-Agent parte por parte, como ver a sua e como alterá-la no Chrome, no Windows 11 e no Android. A segunda metade é mais técnica: a redução do User-Agent no Chrome, os cabeçalhos Client Hints que ocuparam o lugar dela, o que não muda quando você altera o User-Agent e como um script escrito por você deve se identificar.

> **Nota: Resposta rápida**
>
> User-Agent é a linha de identidade que um navegador ou programa envia em cada requisição HTTP, informando nome, versão e sistema operacional. Você vê o seu valor digitando `navigator.userAgent` no console do navegador. No Chrome, ele é alterado em DevTools > More tools > Network conditions; no Android, com a opção "Site para computador". Essa linha não carrega o seu endereço IP nem a sua localização, e alterá-la não muda os outros rastros do navegador.

## O que é User-Agent?

Quando o navegador pede uma página, ele não envia ao servidor apenas o endereço. No topo da requisição seguem linhas curtas de informação chamadas cabeçalhos (headers): quais idiomas você prefere, quais tipos de arquivo aceita e qual software está enviando a requisição. Este último é o cabeçalho `User-Agent`.

O padrão HTTP [RFC 9110 define esse cabeçalho](https://www.rfc-editor.org/rfc/rfc9110.html#field.user-agent) como o campo que traz informações sobre o software que origina a requisição. Os servidores usam essa informação em três tarefas: descobrir em qual navegador aparece um problema de compatibilidade, adaptar a resposta às limitações do cliente e manter estatísticas de navegadores e sistemas operacionais. O padrão recomenda que o cliente envie esse cabeçalho em todas as requisições.

A expressão "user agent" é, na verdade, o nome do software, e não do cabeçalho: todo programa que envia requisições em seu nome é um agente do usuário. Um navegador, o bot de um buscador, um aplicativo de celular, o comando `curl` e um script Python se encaixam nessa definição, e todos têm um valor de User-Agent.

Vale corrigir dois enganos logo de início. O User-Agent **não contém o seu endereço IP nem a sua localização.** O endereço IP é lido da própria conexão; explicamos como ele muda em [nosso guia para mudar o endereço IP](/pt-br/blog/how-to-change-ip-address). O User-Agent também não é **autenticação**: é uma declaração do próprio cliente, e o servidor não consegue verificar se ela é verdadeira olhando o cabeçalho.

## Como ler uma string de User-Agent?

Um Chrome atual no Windows envia este valor (o exemplo é da [página User-Agent da MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent)):

```text
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36
```

Ao lado de Chrome, a linha também traz os nomes Mozilla, AppleWebKit, Gecko e Safari. O motivo é histórico. Durante anos os sites escreveram regras do tipo "se o User-Agent tiver este nome, envie a página avançada". Cada navegador novo acrescentou os nomes dos antigos à própria linha para não ficar sem essa página. Nas palavras da MDN, `Mozilla/5.0` é um token genérico que diz que o navegador é compatível com Mozilla e, por razões históricas, quase todo navegador o envia hoje.

| Parte | O que ela diz? |
|---|---|
| `Mozilla/5.0` | Resquício de compatibilidade; não distingue navegadores |
| `(Windows NT 10.0; Win64; x64)` | Sistema operacional e arquitetura do processador |
| `AppleWebKit/537.36 (KHTML, like Gecko)` | Nomes de motores, também incluídos por compatibilidade |
| `Chrome/143.0.0.0` | O navegador de fato e sua versão principal |
| `Safari/537.36` | Um nome incluído para sites escritos pensando no Safari |

A regra prática de leitura é esta: o sistema operacional fica dentro do primeiro parêntese, e o nome real do navegador costuma estar perto do fim da linha. O Edge acrescenta `Edg/` ao final, o Firefox termina com `Firefox/`. Nos celulares entra na linha a palavra `Mobile`; os sites que escolhem a página móvel pelo User-Agent procuram essa palavra.

Mais um detalhe: mesmo que você use o Windows 11, dentro do parêntese aparece `Windows NT 10.0`. A Microsoft diz com todas as letras [na própria documentação](https://learn.microsoft.com/pt-br/microsoft-edge/web-platform/how-to-detect-win11) que as strings de User-Agent não serão atualizadas para diferenciar o Windows 10 do Windows 11. Você verá o motivo mais abaixo, na seção sobre a redução do User-Agent.

## Como descobrir o seu User-Agent?

Não é preciso instalar nada. As ferramentas do próprio navegador bastam:

1. Em qualquer página no Chrome ou no Edge, pressione `F12` (ou os três pontos no canto superior direito > Mais ferramentas > Ferramentas do desenvolvedor).
2. No painel que se abre, vá para a aba **Console**.
3. Digite `navigator.userAgent` e pressione Enter. A linha devolvida entre aspas é o User-Agent que o navegador informa ao JavaScript.
4. Para ver o que realmente chega ao servidor, vá para a aba **Network**, recarregue a página, clique na primeira requisição da lista e localize a linha `User-Agent` em "Request Headers".

O esperado é que os passos três e quatro mostrem o mesmo valor. Se forem diferentes, uma extensão ou uma configuração está alterando apenas um dos dois.

Se preferir não usar o console, também serve uma página que devolve, sem mexer, os cabeçalhos da requisição que recebe. Abra `https://httpbin.org/headers` no navegador e você verá todos os cabeçalhos que o servidor recebeu de você; usaremos o mesmo endereço na parte de código do artigo.

## Como alterar o User-Agent?

Antes, saiba o que está alterando: o User-Agent não é uma configuração do sistema operacional, e sim de **cada navegador**. Nem o Windows 11 nem o Android têm uma configuração única de User-Agent que valha para todos os programas.

### Chrome e Edge (Windows 11, Windows 10, macOS)

O caminho oficial do Chrome é [a aba Network conditions do DevTools](https://developer.chrome.com/docs/devtools/device-mode/override-user-agent?hl=pt-br). O Edge também é baseado no Chromium e por isso traz as mesmas ferramentas.

1. Abra o DevTools com `F12`.
2. Siga os três pontos no canto superior direito do painel > **More tools** > **Network conditions**. Se não encontrar no menu, abra o menu de comandos com `Ctrl+Shift+P` e digite "Network conditions".
3. Sob o título **User agent**, desmarque a caixa "Use browser default".
4. Escolha na lista um navegador e um dispositivo prontos, ou digite a sua própria string na opção "Custom...".
5. Recarregue a página.

O campo "User agent client hints", na mesma seção, permite editar também os valores de Client Hints explicados mais abaixo. Essa alteração não é uma configuração permanente do navegador; ela vale durante o teste, na aba em que o DevTools está aberto. Usamos aqui os nomes em inglês do DevTools; se a sua interface aparecer em português, os itens ficam no mesmo lugar.

### Celular Android

No Android não existe um jeito nativo de digitar um User-Agent à mão, mas a alteração mais procurada é um toque só. No Chrome, toque nos três pontos no canto superior direito e marque a caixa **Site para computador**; o Chrome passa a visitar aquele site com identidade de desktop e o layout largo aparece. Para tornar isso o padrão em todos os sites, [o caminho indicado na Ajuda do Chrome](https://support.google.com/chrome/answer/13514529?hl=pt-BR&co=GENIE.Platform%3DAndroid) é: Configurações > Configurações de sites > Site para computador.

### O que é um User-Agent switcher?

As extensões que aparecem nas lojas dos navegadores com o nome "User-Agent switcher" fazem o mesmo trabalho sem abrir o DevTools e de forma permanente: você escolhe uma identidade em uma lista, e a extensão troca por ela o cabeçalho `User-Agent` das requisições que saem. Antes de instalar, veja a permissão que ela pede. Para conseguir alterar cabeçalhos, a extensão precisa de acesso ao seu tráfego em todos os sites visitados; conceda essa permissão apenas a uma extensão de origem confiável e desative-a quando terminar.

### Por que alterar o User-Agent?

Todos os motivos legítimos são algum tipo de teste:

- **Experimentar a visualização móvel no computador.** Ver qual página o seu próprio site envia para um celular.
- **Depurar um problema de compatibilidade.** Descobrir se uma página corporativa antiga que diz "seu navegador não é compatível" realmente não funciona.
- **Ver o que o seu próprio site mostra aos bots.** Encontrar um erro de configuração que devolve conteúdo diferente aos bots dos buscadores.
- **Reproduzir um bug.** Examinar um problema que só aparece em determinado navegador quando você não tem esse navegador à mão.

A RFC 9110 também prevê essa situação: se um cliente se apresenta como outro cliente, o servidor pode supor que o usuário quer ver a resposta preparada para aquele cliente, mesmo que ela não funcione bem no navegador real. A responsabilidade é de quem fez a alteração.

## O que é a redução do User-Agent (UA reduction)?

As strings de User-Agent antigas eram muito mais faladoras do que as de hoje: a versão completa do navegador com quatro números, o nível de patch do sistema operacional e, no Android, o modelo do celular. Reunidos, esses detalhes eram uma peça pronta do [fingerprint do navegador](/pt-br/blog/browser-fingerprinting), usado para reconhecer um usuário sem cookies. A RFC 9110 faz o mesmo alerta: valores de User-Agent detalhados demais aumentam o risco de o usuário ser identificado contra a própria vontade.

Por isso o Chrome simplificou a string em etapas. De acordo com [o cronograma do projeto Chromium](https://www.chromium.org/updates/ua-reduction/), os números de versão secundária foram congelados no Chrome 101, as informações do sistema operacional de desktop no Chrome 107, e a versão do Android e o modelo do dispositivo no Chrome 110. Na string que o Chrome envia hoje, estas partes não são reais, e sim fixas:

| Parte | Sem a redução (exemplo) | Hoje |
|---|---|---|
| Versão do navegador | `Chrome/143.0.12.45` | `Chrome/143.0.0.0` (só a versão principal é real) |
| Windows | Versão real | Sempre `Windows NT 10.0; Win64; x64` |
| macOS | Versão real | Sempre `Intel Mac OS X 10_15_7` |
| Android | `Android 16; Pixel 9` | Sempre `Android 10; K` |

É por isso que você vê `NT 10.0` no Windows 11, e "Android 10" com um modelo chamado "K" em um celular novinho. A conclusão também é clara: uma ferramenta de estatísticas que tenta ler a versão do sistema operacional ou o modelo do celular no User-Agent de um Chrome atual produz resultados errados.

## O que são Client Hints?

Há sites que realmente precisam da informação que sumiu com a simplificação: os que querem sugerir o instalador correto ou saber em qual versão um bug aparece. O Chrome não apagou essa informação, ele a tornou **disponível sob pedido**. O mecanismo se chama User-Agent Client Hints e, como descreve [o guia de Client Hints da MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Client_hints), funciona assim:

1. Na primeira requisição, junto com o `User-Agent` simplificado, o navegador envia três cabeçalhos curtos: `Sec-CH-UA` (marca do navegador e versão principal), `Sec-CH-UA-Mobile` (se é móvel) e `Sec-CH-UA-Platform` (nome do sistema operacional).
2. O servidor que quer mais informa na resposta, pelo cabeçalho `Accept-CH`, quais dicas deseja.
3. O navegador acrescenta as dicas que permite às requisições seguintes para aquele site.
4. Se uma dica é indispensável já na primeira requisição, o servidor usa o cabeçalho `Critical-CH`; o navegador reenvia a requisição com essa dica incluída.

Os três cabeçalhos padrão aparecem assim em uma requisição do Chrome:

```text
Sec-CH-UA: "Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"
Sec-CH-UA-Mobile: ?0
Sec-CH-UA-Platform: "Windows"
```

"Not A(Brand" na lista não é um erro. Segundo a MDN, os navegadores acrescentam de propósito uma marca falsa à lista; o objetivo é impedir que os servidores criem o hábito de rejeitar uma requisição ao ver um nome que não conhecem. É uma precaução para que a história do `Mozilla/5.0` não se repita.

| Tipo de dica | Cabeçalhos | Quando é enviada? |
|---|---|---|
| Baixa entropia | `Sec-CH-UA`, `Sec-CH-UA-Mobile`, `Sec-CH-UA-Platform` | Em toda requisição, por padrão (somente HTTPS) |
| Alta entropia | `Sec-CH-UA-Platform-Version`, `Sec-CH-UA-Full-Version-List`, `Sec-CH-UA-Model`, `Sec-CH-UA-Arch` | Somente se o servidor pedir com `Accept-CH` |

A mesma informação fica disponível ao JavaScript por `navigator.userAgentData`. Cole as linhas abaixo no console do Chrome para ver os seus próprios valores:

```js
console.log(navigator.userAgent);

if (navigator.userAgentData) {
  const details = await navigator.userAgentData.getHighEntropyValues([
    "platformVersion",
    "model",
    "fullVersionList",
  ]);
  console.log(details);
}
```

No Windows 11 esse código devolve, para `platformVersion`, uma versão principal igual ou superior a 13; é o método que a documentação da Microsoft mostra para diferenciar o Windows 10 do Windows 11. Na máquina com Windows 11 que testamos, o `User-Agent` continuava dizendo `Windows NT 10.0`, enquanto `platformVersion` veio como `19.0.0`.

Conheça também o limite. Hoje os Client Hints existem apenas em navegadores baseados no Chromium (Chrome, Edge, Opera). Nos dados de compatibilidade da MDN, o Firefox e o Safari não enviam esses cabeçalhos, e o objeto `navigator.userAgentData` não é definido neles. Por isso a verificação `if` do código acima é necessária.

## O que não muda quando você altera o User-Agent?

O User-Agent é uma etiqueta, e trocar a etiqueta não troca o que está dentro da caixa. Quando você define a linha como "Safari no iPhone", isto continua no lugar:

- **Os cabeçalhos Client Hints.** Se você usou uma ferramenta que altera apenas o cabeçalho `User-Agent`, o Chrome continua enviando `Sec-CH-UA-Platform: "Windows"`. O Safari não envia esses cabeçalhos de forma alguma; ou seja, a sua requisição diz ser Safari e, ao mesmo tempo, carrega cabeçalhos que só o Chromium envia.
- **O que o JavaScript enxerga.** Tamanho da tela, fontes instaladas, placa de vídeo, suporte a tela sensível ao toque. Listamos esses sinais em [O que é fingerprint do navegador?](/pt-br/blog/browser-fingerprinting).
- **A própria conexão.** O primeiro pacote que o navegador envia ao estabelecer uma conexão criptografada tem uma organização diferente em cada família de navegadores e segue antes dos cabeçalhos. Os detalhes estão em [nosso artigo sobre fingerprint TLS e JA3](/pt-br/blog/tls-fingerprinting).
- **O endereço IP.** A requisição continua saindo pela sua conexão, com o seu endereço IP.

Por isso, alterar o User-Agent é uma ferramenta de teste, não de invisibilidade. Os sistemas de proteção contra bots não olham um único cabeçalho, e sim se os sinais são coerentes entre si; contamos o quadro completo, do ponto de vista do dono do site, em [nosso artigo sobre como funciona a detecção de bots](/pt-br/blog/how-bot-detection-works). O software que assume a tarefa de montar um conjunto de identidade coerente por perfil é uma categoria à parte: [O que é um navegador antidetect e como ele funciona?](/pt-br/blog/what-is-antidetect-browser).

## User-Agent no código: valores padrão e uma identidade de bot honesta

Todo cliente fora do navegador também tem um User-Agent e, se você não configurou nada, ele é o nome da própria biblioteca. Medimos os valores abaixo na nossa máquina para este artigo; o número de versão será diferente na sua:

| Cliente | User-Agent padrão |
|---|---|
| `curl` | `curl/8.21.0` |
| Python Requests | `python-requests/2.34.2` |
| Node.js (`fetch` nativo) | `node` |

Esses valores não estão errados, são honestos. O que falta neles é isto: eles não dizem ao administrador do site **quem você é nem como entrar em contato.** Um administrador que vê milhares de linhas `python-requests` nos logs só tem uma opção, que é bloquear.

Para um script de coleta de dados que roda com regularidade, a boa prática consolidada é escrever uma identidade que siga a forma "produto/versão (comentário)" da RFC 9110 e traga o nome do bot e um meio de contato. Os bots dos buscadores fazem o mesmo; o valor do Googlebot tem a forma `Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)`. Com o `curl`, é uma linha só:

```bash
# Veja a identidade padrão
curl -s https://httpbin.org/headers

# Escreva a sua própria identidade com -A
curl -s -A "ExamplePriceBot/1.0 (+https://example.com/bot-info)" https://httpbin.org/headers
```

No Python, escreva a identidade na sessão, e não em cada requisição. Assim todas as requisições saem com a mesma identidade, e a configuração do proxy também fica em um lugar só:

```python
import requests

URL = "https://httpbin.org/headers"
BOT_UA = "ExamplePriceBot/1.0 (+https://example.com/bot-info; bot@example.com)"

# 1) Sem configurar nada: a identidade da própria biblioteca
print(requests.get(URL, timeout=20).json()["headers"]["User-Agent"])

# 2) Identidade fixa que se apresenta e proxy para a sessão inteira
session = requests.Session()
session.headers["User-Agent"] = BOT_UA
proxy = "http://user:pass@pr.proxynet.io:8000"
session.proxies = {"http": proxy, "https": proxy}

for _ in range(3):
    print(session.get(URL, timeout=20).json()["headers"]["User-Agent"])
```

A primeira linha imprime `python-requests/2.x`, as três seguintes imprimem a identidade que você escreveu. No Node.js o mesmo trabalho é feito pelo campo `headers` da chamada `fetch`:

```js
const url = "https://httpbin.org/headers";

// 1) Identidade padrão
let res = await fetch(url);
console.log((await res.json()).headers["User-Agent"]);

// 2) A identidade que você escreveu
res = await fetch(url, {
  headers: { "User-Agent": "ExamplePriceBot/1.0 (+https://example.com/bot-info; bot@example.com)" },
});
console.log((await res.json()).headers["User-Agent"]);
```

Salve o arquivo com a extensão `.mjs`; a primeira linha da saída será `node`. Definir um proxy no Node.js é outro assunto, e [Como usar proxy no Node.js](/pt-br/blog/nodejs-proxy) traz exemplos testados. Todas as opções de proxy do lado do `curl` estão em [Como usar cURL com proxy](/pt-br/blog/curl-proxy).

### Por que um User-Agent aleatório a cada requisição não adianta?

A maioria dos guias de scraping na internet sugere baixar uma "lista de User-Agents atualizada" e sortear um item a cada requisição. Você viu o mecanismo na seção anterior: só a etiqueta muda. Quando o mesmo endereço IP, o mesmo cookie e o mesmo rastro de conexão dizem ser Chrome no Windows em uma requisição e Safari no iPhone na seguinte, o resultado é um tráfego que não se parece com nenhum usuário real. Uma identidade única, fixa e que se apresenta é coerente e ainda deixa para o administrador do site alguém com quem falar. Damos exemplos de coerência na seção "Cabeçalhos e uma identidade de cliente coerente" de [Como fazer web scraping sem ser bloqueado](/pt-br/blog/web-scraping-without-getting-blocked).

### Por que não é recomendável se passar pelo Googlebot?

Alguns guias sugerem escrever o valor do Googlebot no User-Agent. Não faça isso, por dois motivos. Primeiro, não funciona: o Google orienta os sites a [verificar o bot dele com uma consulta de DNS reverso ou com as faixas de IP que publica](https://developers.google.com/crawling/docs/crawlers-fetchers/verify-google-requests). Um endereço IP que diz ser o Googlebot, mas que na consulta de DNS reverso não resolve sob `googlebot.com`, `google.com` ou `googleusercontent.com`, é bloqueado mais rápido do que um bot comum. Segundo, usar a identidade de outra organização é sair do limite da permissão que o site deu a você. O único uso legítimo é o teste citado acima: ver o que **o seu próprio** site devolve a essa identidade.

Um nome de bot honesto tem mais uma vantagem. A linha `User-agent:` do arquivo robots.txt usa a mesma palavra, mas é outra coisa: é a linha em que o dono do site indica para qual bot a regra foi escrita. Se o nome do seu bot é conhecido, o dono do site pode escrever uma regra específica para você, e você a cumpre. Como o arquivo é lido está em [O que é robots.txt e como ler o arquivo?](/pt-br/blog/robots-txt).

## Proxy e User-Agent: o proxy muda o IP, a identidade é com você

Proxy e User-Agent são confundidos com frequência, porque os dois fazem parte da pergunta "como o site me vê". A divisão de tarefas é clara: o proxy muda de qual endereço IP e de qual país a requisição sai. Ele não toca no User-Agent. Em uma conexão HTTPS, nem consegue: o proxy apenas estabelece o túnel criptografado e não enxerga os cabeçalhos que passam por dentro. No exemplo em Python acima, o User-Agent que o site vê é o mesmo com e sem proxy.

A regra que sai daí é que os dois devem **contar a mesma história.** Se você testa o seu próprio site móvel ou o back-end do seu aplicativo pelos olhos de um usuário de celular em Türkiye, um User-Agent móvel combina com um IP que sai da rede de uma operadora móvel; para isso se usa [Proxies móveis](https://proxynet.io/pt-br/mobile-proxy). Se você verifica o preço ou o anúncio que um usuário doméstico vê, uma identidade de navegador desktop com [Proxies residenciais](https://proxynet.io/pt-br/residential-proxy) forma um par coerente. Um "celular" que chega de um IP de data center, ou uma requisição que vem de um IP da Alemanha e envia `Accept-Language: tr`, é contraditória por mais cuidado que se tenha na escolha do User-Agent.

## Casos de uso

- **Teste comparativo das versões móvel e desktop.** Abrir a mesma página com duas identidades e com o IP do país de destino para ver as diferenças: [solução para testes de aplicativos](/pt-br/app-testing).
- **Coleta de dados regular com nome próprio.** Identidade de bot fixa, respeito ao robots.txt e limite de taxa funcionam juntos: [solução de data scraping](/pt-br/data-scraping).
- **Rastreamento de sites e verificação de links.** Se você escreve o seu próprio crawler, a linha de identidade é o primeiro item de configuração: [solução de web crawler](/pt-br/web-crawler).
- **Acompanhar a diferença entre móvel e desktop nos resultados de busca.** O ranqueamento muda conforme o tipo de dispositivo e a localização: [solução de proxy para SEO](/pt-br/seo-proxy).
- **Automação de navegador.** No Playwright, o User-Agent é informado na criação do contexto e vale para todas as páginas daquele contexto: [O que é Playwright e como usá-lo com proxy](/pt-br/blog/playwright-proxy).

## Erros comuns

- **Achar que alterar o User-Agent também esconde o IP.** São camadas separadas; o User-Agent não tem informação de IP.
- **Alterar só o cabeçalho e esquecer os Client Hints.** O Chrome continua informando o sistema operacional real em `Sec-CH-UA-Platform`.
- **Ler a versão do sistema operacional no User-Agent.** No Chrome atual esses campos são fixos; o Windows 11 e as versões novas do Android não aparecem na string.
- **Usar uma "lista de User-Agents" antiga encontrada na internet.** Uma requisição que informa uma versão do Chrome de anos atrás não se parece com tráfego real de navegador, e alguns sites enviam uma página incompleta para versões antigas.
- **Sortear uma identidade ou se passar pelo Googlebot.** O primeiro, com o mesmo IP e o mesmo cookie, é um sinal de incoerência; o segundo não passa na verificação por DNS reverso.
- **Instalar uma extensão switcher sem olhar as permissões.** Uma extensão que altera cabeçalhos pode ver todo o seu tráfego.
- **Deixar a alteração ligada depois do teste.** Quando "Site para computador" ou a extensão ficam ligados, os sites começam a parecer quebrados e ninguém lembra o motivo.

## Guia de decisão

| Necessidade | Recomendação |
|---|---|
| Quero ver o meu próprio User-Agent | `navigator.userAgent` no console ou `httpbin.org/headers` |
| Vou experimentar a visualização móvel no computador | DevTools > More tools > Network conditions |
| Vou abrir a página desktop no celular | "Site para computador" no menu do Chrome |
| Preciso saber se o visitante usa Windows 11 | `Sec-CH-UA-Platform-Version` ou `getHighEntropyValues` |
| Estou escrevendo um scraper que roda com regularidade | Uma única identidade de bot fixa, com nome e endereço de contato |
| Vou testar como apareço a partir de outro país e outro dispositivo | User-Agent adequado ao dispositivo junto com um IP de proxy do mesmo tipo |
| Quero ver o que o meu site mostra aos bots | Teste com identidade de bot somente no seu próprio site |
| Quero passar pela proteção contra bots de um site usando o User-Agent | Esse caminho não funciona; API oficial ou permissão do dono do site |

## Perguntas frequentes

### O que significa User-Agent?

Ao pé da letra, "agente do usuário": o software que envia requisições à internet em seu nome. No uso do dia a dia, o termo se refere ao texto do cabeçalho `User-Agent`, que esse software envia em cada requisição para informar nome, versão e sistema operacional.

### O User-Agent mostra o meu endereço IP ou a minha localização?

Não. A string traz apenas informações do software e do sistema operacional. O site descobre o seu endereço IP pela própria conexão e a sua localização aproximada a partir desse endereço IP. Alterar o User-Agent não afeta nenhuma das duas coisas.

### Alterar o User-Agent é legal?

Alterar um cabeçalho que o seu próprio navegador envia não é, por si só, um ato proibido; os navegadores trazem um menu pronto para isso nas ferramentas do desenvolvedor. O que pesa é o que você faz depois de alterar. Agir como o bot de outra organização ou contornar os termos de uso de um site causa problema, não importa como o cabeçalho foi configurado. Tratamos do enquadramento legal da coleta de dados em [Web scraping é legal?](/pt-br/blog/is-data-web-scraping-legal).

### Por que o User-Agent mostra Windows 10 no Windows 11?

Os navegadores baseados no Chromium fixaram o campo do sistema operacional no valor `Windows NT 10.0`. A versão real é obtida pelo cabeçalho `Sec-CH-UA-Platform-Version`; uma versão principal igual ou superior a 13 significa Windows 11.

### Os Client Hints substituíram o User-Agent?

Ainda não. O cabeçalho `User-Agent` continua sendo enviado por todos os navegadores; o Chrome apenas simplificou o conteúdo dele. Os Client Hints são um mecanismo adicional que entrega o detalhe aos sites que pedem, por um caminho com permissão, e por enquanto existem apenas em navegadores baseados no Chromium. Para usuários do Firefox e do Safari, os sites ainda olham a string `User-Agent`.

### O User-Agent muda quando uso um proxy?

Não muda. O proxy muda o endereço IP de onde a requisição sai; os cabeçalhos que você envia continuam iguais. Planeje os dois juntos: o tipo de dispositivo quem conta é o User-Agent, e a localização e o tipo de rede quem conta é o proxy.

## Em resumo

O User-Agent é a declaração de uma linha em que o software que envia a requisição se apresenta. Começar com `Mozilla/5.0` é um resquício histórico de compatibilidade; a informação de verdade está dentro do parêntese e no fim da linha. O Chrome simplificou essa linha e levou o detalhe para os cabeçalhos Client Hints; é por isso que o Windows 11 aparece como `NT 10.0` e os celulares novos como `Android 10; K`. Alterar é fácil (a aba Network conditions, a caixa "Site para computador", `curl -A`), mas só a etiqueta muda: Client Hints, sinais de JavaScript, rastro de conexão e endereço IP continuam no lugar. No seu próprio script, use, em vez de identidades aleatórias, uma única identidade com o seu nome e o seu endereço de contato, e não se passe por outro bot. Para endereços IP coerentes com o dispositivo e a localização que você testa, conheça [nossos serviços de proxy](/pt-br/proxy).