Gere strings de user agent de navegador realistas com opções para filtrar por tipo de dispositivo, família de navegador e sistema operacional. Perfeito para testes de desenvolvimento web e verificações de compatibilidade.
Gere strings de agente de usuário realistas e aleatórias para testes de desenvolvimento web.
Uma string de User Agent é um identificador de texto específico que navegadores da web e outras aplicações enviam para sites para se identificarem. Esta string geralmente contém informações sobre o navegador, sistema operacional, tipo de dispositivo e motor de renderização sendo utilizado. Para desenvolvedores e testadores web, ter acesso a uma variedade de strings de user agent realistas é essencial para testar a compatibilidade, responsividade e funcionalidade do site em diferentes plataformas.
Esta ferramenta Gerador de User Agent Aleatório cria strings de user agent com aparência autêntica com base nos parâmetros selecionados. Você pode filtrar por tipo de dispositivo (desktop ou móvel), família de navegador (Chrome, Firefox, Safari ou Edge) e sistema operacional para gerar user agents que correspondam às suas necessidades de teste. A ferramenta fornece uma interface simples com opções para copiar a string gerada com um único clique e gerar novas strings aleatórias instantaneamente.
Strings de user agent seguem padrões específicos dependendo do navegador e da plataforma, mas geralmente contêm vários componentes comuns:
Aqui está uma análise das estruturas típicas de user agent para navegadores principais:
1Mozilla/5.0 (plataforma; detalhes) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/versão Safari/537.36
21Mozilla/5.0 (plataforma; rv:versãogecko) Gecko/trilhaGecko Firefox/versãofirefox
21Mozilla/5.0 (plataforma) AppleWebKit/webkitversão (KHTML, como Gecko) Versão/safariversão Safari/safariversão
21Mozilla/5.0 (plataforma) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/versãochromium Safari/537.36 Edg/versãoedge
2A seção da plataforma varia significativamente entre dispositivos desktop e móveis:
Exemplos de Desktop:
Windows NT 10.0; Win64; x64Macintosh; Intel Mac OS X 10_15_7X11; Linux x86_64Exemplos Móveis:
Linux; Android 12; SM-G998BiPhone; CPU iPhone OS 15_4 como Mac OS XUser agents de desktop geralmente incluem informações específicas do sistema operacional, detalhes da arquitetura (como x86_64 ou Win64), e às vezes preferências de idioma. Eles tendem a ser mais consistentes entre navegadores do que user agents móveis.
User agents móveis contêm informações do modelo do dispositivo, versões do sistema operacional móvel e frequentemente incluem a palavra "Mobile" no final. O Safari móvel em dispositivos iOS incluirá identificadores "iPhone" ou "iPad", enquanto dispositivos Android incluem o fabricante e o número do modelo.
Cada navegador segue diferentes padrões de versionamento:
A geração aleatória de user agents tem várias aplicações importantes em desenvolvimento e teste web:
Teste de Compatibilidade entre Navegadores: Teste como seu site é renderizado e funciona em diferentes navegadores sem precisar instalar vários navegadores ou usar vários dispositivos.
Teste de Design Responsivo: Verifique se seu site detecta corretamente dispositivos móveis e desktop e serve o layout apropriado.
Validação de Detecção de Recursos: Garanta que os mecanismos de detecção de recursos do seu site funcionem corretamente para diferentes capacidades de navegador.
QA e Testes Automatizados: Incorpore diferentes user agents em seus scripts de teste automatizados para simular vários ambientes de usuário.
Teste de Performance: Analise como seu site se comporta quando acessado de diferentes ambientes de navegador.
Depuração de Problemas Específicos de Navegador: Reproduza e corrija bugs que ocorrem apenas em navegadores ou versões específicas.
Teste de API: Teste como sua API lida com solicitações de diferentes aplicações cliente.
Embora nosso gerador de user agent aleatório seja útil para muitos cenários de teste, existem abordagens alternativas:
Serviços de Teste de Navegadores: Plataformas como BrowserStack, Sauce Labs ou LambdaTest fornecem instâncias reais de navegadores para testes em vez de apenas simular o user agent.
Ferramentas de Desenvolvedor do Navegador: A maioria dos navegadores modernos permite que você substitua o user agent por meio de suas ferramentas de desenvolvedor, o que pode ser útil para testes rápidos.
Extensões de Troca de User Agent: Extensões de navegador que permitem alternar entre user agents pré-definidos enquanto navega.
Máquinas Virtuais ou Contêineres: Executando instâncias reais de diferentes sistemas operacionais e navegadores para testes mais precisos.
Testes de Navegador Sem Cabeça: Usando ferramentas como Puppeteer ou Selenium para controlar programaticamente navegadores com diferentes configurações de user agent.
Cada alternativa tem suas próprias vantagens e pode ser mais apropriada dependendo de suas necessidades e recursos específicos de teste.
O conceito de string de user agent remonta aos primeiros dias da World Wide Web. O termo "user agent" vem da especificação HTTP, onde se refere à aplicação cliente que faz uma solicitação a um servidor web.
O primeiro navegador amplamente utilizado, o NCSA Mosaic, incluía uma string de user agent simples que identificava o nome e a versão do navegador. Quando o Netscape Navigator foi lançado, ele usou um formato semelhante. No entanto, à medida que servidores web começaram a entregar conteúdo diferente com base no navegador, surgiu uma prática conhecida como "sniffing de navegador".
Durante as guerras dos navegadores entre Netscape e Internet Explorer, sites frequentemente serviam conteúdo otimizado exclusivamente para navegadores específicos. Para garantir compatibilidade, os navegadores começaram a incluir strings que se identificavam como outros navegadores. É por isso que a maioria dos navegadores modernos ainda inclui "Mozilla" em suas strings de user agent, uma referência ao codinome do Netscape Navigator.
O surgimento de dispositivos móveis introduziu nova complexidade às strings de user agent. Navegadores móveis precisavam se identificar como móveis para receber conteúdo apropriado, levando à adição de identificadores de dispositivos e tokens específicos para móveis.
À medida que o ecossistema da web se tornou mais complexo, as strings de user agent se tornaram cada vez mais confusas. Elas agora contêm referências a vários motores de navegador (como "AppleWebKit" e "Gecko") por razões de compatibilidade, mesmo quando esses motores não estão realmente sendo usados.
Essa complexidade levou a desafios na análise precisa das strings de user agent, e alguns grupos de padrões da web propuseram descontinuar ou simplificar as strings de user agent em favor de "client hints" mais estruturados. No entanto, por razões de compatibilidade retroativa, a string de user agent tradicional continua sendo uma parte essencial da navegação na web.
Aqui estão exemplos de como trabalhar com strings de user agent em várias linguagens de programação:
1// JavaScript: Detectando tipo de navegador a partir do user agent
2function detectBrowser() {
3 const userAgent = navigator.userAgent;
4
5 if (userAgent.indexOf("Firefox") > -1) {
6 return "Firefox";
7 } else if (userAgent.indexOf("SamsungBrowser") > -1) {
8 return "Samsung Browser";
9 } else if (userAgent.indexOf("Opera") > -1 || userAgent.indexOf("OPR") > -1) {
10 return "Opera";
11 } else if (userAgent.indexOf("Trident") > -1) {
12 return "Internet Explorer";
13 } else if (userAgent.indexOf("Edge") > -1) {
14 return "Edge";
15 } else if (userAgent.indexOf("Chrome") > -1) {
16 return "Chrome";
17 } else if (userAgent.indexOf("Safari") > -1) {
18 return "Safari";
19 } else {
20 return "Desconhecido";
21 }
22}
23
24// Uso
25console.log("Você está usando: " + detectBrowser());
261# Python: Definindo user agent personalizado em requests
2import requests
3
4def fetch_with_user_agent(url, user_agent):
5 headers = {
6 'User-Agent': user_agent
7 }
8 response = requests.get(url, headers=headers)
9 return response.text
10
11# Exemplo de uso
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100]) # Imprime os primeiros 100 caracteres da resposta
151<?php
2// PHP: Detectando dispositivos móveis usando user agent
3function isMobileDevice() {
4 $userAgent = $_SERVER['HTTP_USER_AGENT'];
5 $mobileKeywords = array('Mobile', 'Android', 'iPhone', 'iPad', 'Windows Phone');
6
7 foreach ($mobileKeywords as $keyword) {
8 if (stripos($userAgent, $keyword) !== false) {
9 return true;
10 }
11 }
12 return false;
13}
14
15// Uso
16if (isMobileDevice()) {
17 echo "Você está usando um dispositivo móvel.";
18} else {
19 echo "Você está usando um dispositivo desktop.";
20}
21?>
221// Java: Gerando um user agent aleatório
2import java.util.Random;
3
4public class UserAgentGenerator {
5 private static final String[] CHROME_VERSIONS = {"96.0.4664.110", "95.0.4638.69", "94.0.4606.81"};
6 private static final String[] OS_VERSIONS = {"Windows NT 10.0; Win64; x64",
7 "Macintosh; Intel Mac OS X 10_15_7",
8 "X11; Linux x86_64"};
9
10 public static String generateRandomChromeUserAgent() {
11 Random random = new Random();
12 String osVersion = OS_VERSIONS[random.nextInt(OS_VERSIONS.length)];
13 String chromeVersion = CHROME_VERSIONS[random.nextInt(CHROME_VERSIONS.length)];
14
15 return "Mozilla/5.0 (" + osVersion + ") AppleWebKit/537.36 (KHTML, como Gecko) " +
16 "Chrome/" + chromeVersion + " Safari/537.36";
17 }
18
19 public static void main(String[] args) {
20 System.out.println(generateRandomChromeUserAgent());
21 }
22}
231# Ruby: Analisando string de user agent
2require 'user_agent_parser'
3
4def parse_user_agent(user_agent_string)
5 parser = UserAgentParser::Parser.new
6 client = parser.parse(user_agent_string)
7
8 {
9 browser_name: client.family,
10 browser_version: client.version.to_s,
11 os_name: client.os.family,
12 os_version: client.os.version.to_s,
13 device: client.device.family
14 }
15end
16
17# Exemplo de uso
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
211// C#: Definindo user agent em HttpClient
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8 static async Task Main()
9 {
10 // Criar HttpClient com user agent personalizado
11 using (var httpClient = new HttpClient())
12 {
13 string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36";
14 httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15
16 try
17 {
18 // Fazer solicitação com user agent personalizado
19 HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20 response.EnsureSuccessStatusCode();
21 string responseBody = await response.Content.ReadAsStringAsync();
22
23 Console.WriteLine($"Resposta recebida com código de status: {response.StatusCode}");
24 Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Primeiros 100 caracteres
25 }
26 catch (HttpRequestException e)
27 {
28 Console.WriteLine($"Erro na solicitação: {e.Message}");
29 }
30 }
31 }
32}
331// Go: Criando solicitações HTTP com user agents personalizados
2package main
3
4import (
5 "fmt"
6 "io/ioutil"
7 "net/http"
8)
9
10func main() {
11 // Criar uma nova solicitação
12 req, err := http.NewRequest("GET", "https://example.com", nil)
13 if err != nil {
14 fmt.Printf("Erro ao criar solicitação: %s\n", err)
15 return
16 }
17
18 // Definir user agent personalizado
19 req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36")
20
21 // Enviar a solicitação
22 client := &http.Client{}
23 resp, err := client.Do(req)
24 if err != nil {
25 fmt.Printf("Erro ao enviar solicitação: %s\n", err)
26 return
27 }
28 defer resp.Body.Close()
29
30 // Ler a resposta
31 body, err := ioutil.ReadAll(resp.Body)
32 if err != nil {
33 fmt.Printf("Erro ao ler resposta: %s\n", err)
34 return
35 }
36
37 fmt.Printf("Status da resposta: %s\n", resp.Status)
38 fmt.Printf("Prévia do corpo da resposta: %s\n", body[:100])
39}
40Aqui estão alguns exemplos de strings de user agent reais para diferentes navegadores e plataformas:
Chrome no Windows:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36
2Firefox no macOS:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:95.0) Gecko/20100101 Firefox/95.0
2Safari no macOS:
1Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Versão/15.2 Safari/605.1.15
2Edge no Windows:
1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36 Edg/96.0.1054.62
2Chrome no Android:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.104 Mobile Safari/537.36
2Safari no iPhone:
1Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 como Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Versão/15.2 Mobile/15E148 Safari/604.1
2Firefox no Android:
1Mozilla/5.0 (Android 12; Mobile; rv:95.0) Gecko/95.0 Firefox/95.0
2Internet Samsung no Galaxy:
1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/16.0 Chrome/92.0.4515.166 Mobile Safari/537.36
2"User Agent." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
"Strings de User Agent do Navegador." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
"Cabeçalho User-Agent HTTP Explicado." KeyCDN, https://www.keycdn.com/support/user-agent
"Client Hints." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
"História da string de user agent do navegador." WebAIM, https://webaim.org/blog/user-agent-string-history/
"Detecção de Navegador Usando o User Agent." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/
Descubra mais ferramentas que podem ser úteis para o seu fluxo de trabalho