Generador de User Agent Aleatorio para Pruebas de Desarrollo Web

Generador Aleatorio de User Agent

Introducción

Una cadena de User Agent es un identificador de texto específico que los navegadores web y otras aplicaciones envían a los sitios web para identificarse. Esta cadena generalmente contiene información sobre el navegador, el sistema operativo, el tipo de dispositivo y el motor de renderizado que se está utilizando. Para los desarrolladores web y los testers, tener acceso a una variedad de cadenas de user agent realistas es esencial para probar la compatibilidad, la capacidad de respuesta y la funcionalidad del sitio web en diferentes plataformas.

Esta herramienta Generador Aleatorio de User Agent crea cadenas de user agent que parecen auténticas basadas en los parámetros que selecciones. Puedes filtrar por tipo de dispositivo (escritorio o móvil), familia de navegador (Chrome, Firefox, Safari o Edge) y sistema operativo para generar user agents que coincidan con tus requisitos de prueba. La herramienta proporciona una interfaz simple con opciones para copiar la cadena generada con un solo clic y generar nuevas cadenas aleatorias al instante.

Estructura del User Agent

Las cadenas de user agent siguen patrones específicos dependiendo del navegador y la plataforma, pero generalmente contienen varios componentes comunes:

Identificador del Navegador: Generalmente comienza con "Mozilla/5.0" por razones de compatibilidad histórica.
Información de Plataforma/SO: Detalles sobre el sistema operativo (Windows, macOS, Android, iOS).
Motor del Navegador: El motor de renderizado (como Gecko, WebKit o Blink).
Detalles del Navegador: El nombre y la versión del navegador específicos.

Aquí hay un desglose de las estructuras típicas de user agent para los principales navegadores:

Chrome

1Mozilla/5.0 (plataforma; detalles) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/version Safari/537.36
2

Firefox

1Mozilla/5.0 (plataforma; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion
2

Safari

1Mozilla/5.0 (plataforma) AppleWebKit/webkitversion (KHTML, como Gecko) Version/safariversion Safari/safariversion
2

Edge

1Mozilla/5.0 (plataforma) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/chromiumversion Safari/537.36 Edg/edgeversion
2

La sección de plataforma varía significativamente entre dispositivos de escritorio y móviles:

Ejemplos de Escritorio:

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

Ejemplos Móviles:

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

Diferencias en el Tipo de Dispositivo

User Agents de Escritorio

Los user agents de escritorio suelen incluir información específica del sistema operativo, detalles de arquitectura (como x86_64 o Win64) y, a veces, preferencias de idioma. Tienden a ser más consistentes entre navegadores que los user agents móviles.

User Agents Móviles

Los user agents móviles contienen información del modelo del dispositivo, versiones del sistema operativo móvil y, a menudo, incluyen la palabra "Mobile" al final. Safari móvil en dispositivos iOS incluirá identificadores de "iPhone" o "iPad", mientras que los dispositivos Android incluyen el fabricante y el número de modelo.

Patrones de Versión del Navegador

Cada navegador sigue diferentes patrones de versionado:

Chrome: Usa números de versión de cuatro partes (por ejemplo, 96.0.4664.110).
Firefox: Típicamente usa números de versión de dos o tres partes (por ejemplo, 95.0 o 95.0.2).
Safari: Usa números de versión simples como 15.2.
Edge: Usa números de versión similares a Chrome pero con su propia versión de Edge (por ejemplo, 96.0.1054.62).

Casos de Uso

La generación aleatoria de user agents tiene varias aplicaciones importantes en el desarrollo y las pruebas web:

Pruebas de Compatibilidad entre Navegadores: Prueba cómo se renderiza y funciona tu sitio web en diferentes navegadores sin necesidad de instalar múltiples navegadores o usar múltiples dispositivos.
Pruebas de Diseño Responsivo: Verifica que tu sitio web detecte correctamente dispositivos móviles y de escritorio y sirva el diseño apropiado.
Validación de Detección de Características: Asegúrate de que los mecanismos de detección de características de tu sitio web funcionen correctamente para diferentes capacidades de navegador.
Pruebas de QA y Automatización: Incorpora diferentes user agents en tus scripts de pruebas automatizadas para simular varios entornos de usuario.
Pruebas de Rendimiento: Analiza cómo se desempeña tu sitio web cuando se accede desde diferentes entornos de navegador.
Depuración de Problemas Específicos de Navegador: Reproduce y corrige errores que solo ocurren en navegadores o versiones específicas.
Pruebas de API: Prueba cómo tu API maneja solicitudes de diferentes aplicaciones cliente.

Alternativas

Si bien nuestro generador aleatorio de user agents es útil para muchos escenarios de prueba, hay enfoques alternativos:

Servicios de Pruebas de Navegadores: Plataformas como BrowserStack, Sauce Labs o LambdaTest proporcionan instancias de navegador reales para pruebas en lugar de solo simular el user agent.
Herramientas de Desarrollo de Navegadores: La mayoría de los navegadores modernos permiten anular el user agent a través de sus herramientas de desarrollo, lo que puede ser útil para pruebas rápidas.
Extensiones de Cambiador de User Agent: Extensiones de navegador que te permiten cambiar entre user agents predefinidos mientras navegas.
Máquinas Virtuales o Contenedores: Ejecutar instancias reales de diferentes sistemas operativos y navegadores para la prueba más precisa.
Pruebas de Navegador Sin Cabeza: Usar herramientas como Puppeteer o Selenium para controlar programáticamente navegadores con diferentes configuraciones de user agent.

Cada alternativa tiene sus propias ventajas y puede ser más apropiada dependiendo de tus necesidades de prueba específicas y recursos.

Historia

El concepto de la cadena de user agent data de los primeros días de la World Wide Web. El término "user agent" proviene de la especificación HTTP, donde se refiere a la aplicación cliente que realiza una solicitud a un servidor web.

Primeros Días (1990s)

El primer navegador ampliamente utilizado, NCSA Mosaic, incluía una cadena de user agent simple que identificaba el nombre y la versión del navegador. Cuando se lanzó Netscape Navigator, utilizó un formato similar. Sin embargo, a medida que los servidores web comenzaron a entregar contenido diferente según el navegador, surgió una práctica conocida como "sniffing de navegador".

Las Guerras de los Navegadores y el Spoofing de User Agent (Finales de 1990s)

Durante las guerras de los navegadores entre Netscape e Internet Explorer, los sitios web a menudo servían contenido optimizado exclusivamente para navegadores específicos. Para garantizar la compatibilidad, los navegadores comenzaron a incluir cadenas que se identificaban a sí mismos como otros navegadores. Esta es la razón por la que la mayoría de los navegadores modernos todavía incluyen "Mozilla" en sus cadenas de user agent, una referencia al nombre en código de Netscape Navigator.

Revolución Móvil (2000s-2010s)

El auge de los dispositivos móviles introdujo nueva complejidad a las cadenas de user agent. Los navegadores móviles necesitaban identificarse como móviles para recibir contenido apropiado, lo que llevó a la adición de identificadores de dispositivo y tokens específicos para móviles.

Desafíos Modernos (2010s-Presente)

A medida que el ecosistema web se ha vuelto más complejo, las cadenas de user agent se han vuelto cada vez más enrevesadas. Ahora contienen referencias a múltiples motores de navegador (como "AppleWebKit" y "Gecko") por razones de compatibilidad, incluso cuando esos motores no se están utilizando realmente.

Esta complejidad ha llevado a desafíos en el análisis preciso de las cadenas de user agent, y algunos grupos de estándares web han propuesto deprecar o simplificar las cadenas de user agent en favor de "client hints" más estructurados. Sin embargo, por razones de compatibilidad hacia atrás, la cadena de user agent tradicional sigue siendo una parte esencial de la navegación web.

Ejemplos de Código

Aquí hay ejemplos de cómo trabajar con cadenas de user agent en varios lenguajes de programación:

1// JavaScript: Detectar tipo de navegador a partir de la cadena de 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 "Desconocido";
21  }
22}
23
24// Uso
25console.log("Estás usando: " + detectBrowser());
26

1# Python: Establecer user agent personalizado en 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# Ejemplo de uso
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100])  # Imprimir los primeros 100 caracteres de la respuesta
15

1<?php
2// PHP: Detectar dispositivos móviles usando la cadena de 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 "Estás usando un dispositivo móvil.";
18} else {
19    echo "Estás usando un dispositivo de escritorio.";
20}
21?>
22

1// Java: Generar un user agent aleatorio
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: Analizar cadena 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# Ejemplo de uso
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, como Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
21

1// C#: Establecer user agent en HttpClient
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8    static async Task Main()
9    {
10        // Crear HttpClient con 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, como Gecko) Chrome/96.0.4664.110 Safari/537.36";
14            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15            
16            try
17            {
18                // Hacer solicitud con 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($"Respuesta recibida con código de estado: {response.StatusCode}");
24                Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Primeros 100 caracteres
25            }
26            catch (HttpRequestException e)
27            {
28                Console.WriteLine($"Error de solicitud: {e.Message}");
29            }
30        }
31    }
32}
33

1// Go: Crear solicitudes HTTP con user agents personalizados
2package main
3
4import (
5    "fmt"
6    "io/ioutil"
7    "net/http"
8)
9
10func main() {
11    // Crear una nueva solicitud
12    req, err := http.NewRequest("GET", "https://example.com", nil)
13    if err != nil {
14        fmt.Printf("Error creando solicitud: %s\n", err)
15        return
16    }
17    
18    // Establecer user agent personalizado
19    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/96.0.4664.110 Safari/537.36")
20    
21    // Enviar la solicitud
22    client := &http.Client{}
23    resp, err := client.Do(req)
24    if err != nil {
25        fmt.Printf("Error enviando solicitud: %s\n", err)
26        return
27    }
28    defer resp.Body.Close()
29    
30    // Leer la respuesta
31    body, err := ioutil.ReadAll(resp.Body)
32    if err != nil {
33        fmt.Printf("Error leyendo respuesta: %s\n", err)
34        return
35    }
36    
37    fmt.Printf("Estado de respuesta: %s\n", resp.Status)
38    fmt.Printf("Vista previa del cuerpo de la respuesta: %s\n", body[:100])
39}
40

Patrones Comunes de User Agent

Aquí hay algunos ejemplos de cadenas de user agent reales para diferentes navegadores y plataformas:

Navegadores de Escritorio

Chrome en Windows:

1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/96.0.4664.110 Safari/537.36
2

Firefox en macOS:

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

Safari en macOS:

1Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, como Gecko) Version/15.2 Safari/605.1.15
2

Edge en Windows:

1Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/96.0.4664.110 Safari/537.36 Edg/96.0.1054.62
2

Navegadores Móviles

Chrome en Android:

1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/96.0.4664.104 Mobile Safari/537.36
2

Safari en iPhone:

1Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, como Gecko) Version/15.2 Mobile/15E148 Safari/604.1
2

Firefox en Android:

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

Samsung Internet en Galaxy:

1Mozilla/5.0 (Linux; Android 12; SM-G998B) AppleWebKit/537.36 (KHTML, como Gecko) SamsungBrowser/16.0 Chrome/92.0.4515.166 Mobile Safari/537.36
2

Referencias

"User Agent." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
"Cadenas de User Agent del Navegador." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
"Encabezado 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
"Historia de la cadena de user agent del navegador." WebAIM, https://webaim.org/blog/user-agent-string-history/
"Detección de Navegadores Usando el User Agent." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/

Whiz Tools

Generador de User Agent Aleatorio para Pruebas de Desarrollo Web

Generador de agente de usuario aleatorio

Agente de usuario generado

Documentación

Generador Aleatorio de User Agent

Introducción

Estructura del User Agent

Chrome

Firefox

Safari

Edge

Diferencias en el Tipo de Dispositivo

User Agents de Escritorio

User Agents Móviles

Patrones de Versión del Navegador

Casos de Uso

Alternativas

Historia

Primeros Días (1990s)

Las Guerras de los Navegadores y el Spoofing de User Agent (Finales de 1990s)

Revolución Móvil (2000s-2010s)

Desafíos Modernos (2010s-Presente)

Ejemplos de Código

Patrones Comunes de User Agent

Navegadores de Escritorio

Navegadores Móviles

Referencias

Retroalimentación

Herramientas Relacionadas

Generador de Ubicaciones Aleatorias: Creador de Coordenadas Globales

Generador de UUIDs: Crea Identificadores Únicos Universales

Generador de Nombres de Proyectos Aleatorios

Generador de Claves API Aleatorias: Crea Cadenas Seguras de 32 Caracteres

Generador de ObjectIDs únicos para MongoDB y pruebas

Generador de identificadores únicos y seguros con Nano ID

Generador de CPF Válido para Pruebas y Desarrollo de Software

Generar y Analizar Herramienta de ID de Snowflake de Twitter para Perspectivas

Generador y validador de IBAN para pruebas y verificación

Generador de Hash MD5