Gerador de User Agent Aleatório para Testes de Desenvolvimento Web

Gerador de User Agent Aleatório

Introdução

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.

Estrutura do User Agent

Strings de user agent seguem padrões específicos dependendo do navegador e da plataforma, mas geralmente contêm vários componentes comuns:

Identificador do Navegador: Geralmente começa com "Mozilla/5.0" por razões de compatibilidade histórica
Informações da Plataforma/SO: Detalhes sobre o sistema operacional (Windows, macOS, Android, iOS)
Motor do Navegador: O motor de renderização (como Gecko, WebKit ou Blink)
Detalhes do Navegador: O nome e a versão do navegador específicos

Aqui está uma análise das estruturas típicas de user agent para navegadores principais:

Chrome

1Mozilla/5.0 (plataforma; detalhes) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/versão Safari/537.36
2

Firefox

1Mozilla/5.0 (plataforma; rv:versãogecko) Gecko/trilhaGecko Firefox/versãofirefox
2

Safari

1Mozilla/5.0 (plataforma) AppleWebKit/webkitversão (KHTML, como Gecko) Versão/safariversão Safari/safariversão
2

Edge

1Mozilla/5.0 (plataforma) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/versãochromium Safari/537.36 Edg/versãoedge
2

A seção da plataforma varia significativamente entre dispositivos desktop e móveis:

Exemplos de Desktop:

Windows: Windows NT 10.0; Win64; x64
macOS: Macintosh; Intel Mac OS X 10_15_7
Linux: X11; Linux x86_64

Exemplos Móveis:

Android: Linux; Android 12; SM-G998B
iOS: iPhone; CPU iPhone OS 15_4 como Mac OS X

Diferenças de Tipo de Dispositivo

User Agents de Desktop

User 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

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.

Padrões de Versão do Navegador

Cada navegador segue diferentes padrões de versionamento:

Chrome: Usa números de versão em quatro partes (por exemplo, 96.0.4664.110)
Firefox: Normalmente usa números de versão em duas ou três partes (por exemplo, 95.0 ou 95.0.2)
Safari: Usa números de versão simples como 15.2
Edge: Usa números de versão semelhantes ao Chrome, mas com sua própria versão Edge (por exemplo, 96.0.1054.62)

Casos de Uso

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.

Alternativas

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.

História

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.

Primeiros Dias (1990s)

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".

As Guerras dos Navegadores e Spoofing de User Agent (Final dos anos 1990)

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.

Revolução Móvel (2000s-2010s)

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.

Desafios Modernos (2010s-Presente)

À 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.

Exemplos de Código

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());
26

1# 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
15

1<?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?>
22

1// 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}
23

1# 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
21

1// 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}
33

1// 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}
40

Padrões Comuns de User Agent

Aqui estão alguns exemplos de strings de user agent reais para diferentes navegadores e plataformas:

Navegadores de Desktop

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
2

Firefox no macOS:

1Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:95.0) Gecko/20100101 Firefox/95.0
2

Safari 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
2

Edge 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
2

Navegadores Móveis

Chrome 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
2

Safari 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
2

Firefox no Android:

1Mozilla/5.0 (Android 12; Mobile; rv:95.0) Gecko/95.0 Firefox/95.0
2

Internet 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

Referências

"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/

Whiz Tools

Gerador de User Agent Aleatório para Testes de Desenvolvimento Web

Gerador de Agente de Usuário Aleatório

Agente de Usuário Gerado

Documentação