Zufälliger User-Agent-Generator für Webentwicklungstests

Zufälliger User-Agent-Generator

Einführung

Ein User-Agent-String ist ein spezifischer Textbezeichner, den Webbrowser und andere Anwendungen an Websites senden, um sich zu identifizieren. Dieser String enthält typischerweise Informationen über den Browser, das Betriebssystem, den Gerätetyp und die verwendete Rendering-Engine. Für Webentwickler und Tester ist der Zugriff auf eine Vielzahl realistischer User-Agent-Strings entscheidend, um die Kompatibilität, Reaktionsfähigkeit und Funktionalität von Websites auf verschiedenen Plattformen zu testen.

Dieses Tool zum Zufälligen User-Agent-Generator erstellt authentisch aussehende User-Agent-Strings basierend auf Ihren ausgewählten Parametern. Sie können nach Gerätetyp (Desktop oder Mobil), Browserfamilie (Chrome, Firefox, Safari oder Edge) und Betriebssystem filtern, um User-Agents zu generieren, die Ihren Testanforderungen entsprechen. Das Tool bietet eine einfache Benutzeroberfläche mit Optionen zum Kopieren des generierten Strings mit einem einzigen Klick und zum sofortigen Generieren neuer zufälliger Strings.

Struktur des User-Agent

User-Agent-Strings folgen spezifischen Mustern, die je nach Browser und Plattform variieren, enthalten jedoch im Allgemeinen mehrere gemeinsame Komponenten:

Browserbezeichner: Beginnt normalerweise mit "Mozilla/5.0" aus historischen Kompatibilitätsgründen
Plattform-/OS-Informationen: Details zum Betriebssystem (Windows, macOS, Android, iOS)
Browser-Engine: Die Rendering-Engine (wie Gecko, WebKit oder Blink)
Browserdetails: Der spezifische Browsername und die Version

Hier ist eine Aufschlüsselung typischer User-Agent-Strukturen für wichtige Browser:

Chrome

1Mozilla/5.0 (plattform; details) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/version Safari/537.36
2

Firefox

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

Safari

1Mozilla/5.0 (plattform) AppleWebKit/webkitversion (KHTML, wie Gecko) Version/safariversion Safari/safariversion
2

Edge

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

Der Plattformabschnitt variiert erheblich zwischen Desktop- und Mobilgeräten:

Desktop-Beispiele:

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

Mobile Beispiele:

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

Unterschiede zwischen Gerätetypen

Desktop-User-Agents

Desktop-User-Agents enthalten typischerweise spezifische Informationen zum Betriebssystem, Architekturdetails (wie x86_64 oder Win64) und manchmal Sprachpräferenzen. Sie sind tendenziell konsistenter zwischen den Browsern als mobile User-Agents.

Mobile-User-Agents

Mobile User-Agents enthalten Geräte-Modellinformationen, Versionen mobiler Betriebssysteme und beinhalten oft das Wort "Mobile" am Ende. Mobile Safari auf iOS-Geräten enthält "iPhone" oder "iPad"-Bezeichner, während Android-Geräte den Hersteller und die Modellnummer enthalten.

Muster der Browserversionen

Jeder Browser folgt unterschiedlichen Versionierungsmustern:

Chrome: Verwendet vierteilige Versionsnummern (z. B. 96.0.4664.110)
Firefox: Verwendet typischerweise zwei- oder dreiteilige Versionsnummern (z. B. 95.0 oder 95.0.2)
Safari: Verwendet einfache Versionsnummern wie 15.2
Edge: Verwendet Versionsnummern ähnlich wie Chrome, jedoch mit eigener Edge-Version (z. B. 96.0.1054.62)

Anwendungsfälle

Die Zufallsgenerierung von User-Agents hat mehrere wichtige Anwendungen in der Webentwicklung und im Testen:

Cross-Browser-Kompatibilitätstests: Testen, wie Ihre Website in verschiedenen Browsern gerendert und funktioniert, ohne mehrere Browser installieren oder mehrere Geräte verwenden zu müssen.
Tests zur responsiven Gestaltung: Überprüfen, ob Ihre Website korrekt mobile und Desktop-Geräte erkennt und das entsprechende Layout bereitstellt.
Validierung der Funktionsüberprüfung: Sicherstellen, dass die Funktionsüberprüfungsmechanismen Ihrer Website für verschiedene Browserfähigkeiten korrekt funktionieren.
QA- und automatisierte Tests: Verschiedene User-Agents in Ihre automatisierten Testscripte integrieren, um verschiedene Benutzerumgebungen zu simulieren.
Leistungstests: Analysieren, wie Ihre Website aus verschiedenen Browserumgebungen heraus funktioniert.
Debugging browser-spezifischer Probleme: Fehler reproduzieren und beheben, die nur in bestimmten Browsern oder Versionen auftreten.
API-Tests: Testen, wie Ihre API mit Anfragen von verschiedenen Client-Anwendungen umgeht.

Alternativen

Während unser Zufälliger User-Agent-Generator für viele Testszenarien nützlich ist, gibt es alternative Ansätze:

Browser-Testdienste: Plattformen wie BrowserStack, Sauce Labs oder LambdaTest bieten tatsächliche Browserinstanzen zum Testen an, anstatt nur den User-Agent zu simulieren.
Browser-Entwicklertools: Die meisten modernen Browser ermöglichen es Ihnen, den User-Agent über ihre Entwicklertools zu überschreiben, was für schnelle Tests nützlich sein kann.
User-Agent-Switcher-Erweiterungen: Browsererweiterungen, die es Ihnen ermöglichen, beim Surfen zwischen vordefinierten User-Agents zu wechseln.
Virtuelle Maschinen oder Container: Tatsächliche Instanzen verschiedener Betriebssysteme und Browser zum genauesten Testen ausführen.
Headless-Browser-Tests: Verwendung von Tools wie Puppeteer oder Selenium, um Browser programmgesteuert mit verschiedenen User-Agent-Einstellungen zu steuern.

Jede Alternative hat ihre eigenen Vorteile und kann je nach Ihren spezifischen Testbedürfnissen und Ressourcen geeigneter sein.

Geschichte

Das Konzept des User-Agent-Strings reicht bis in die frühen Tage des World Wide Web zurück. Der Begriff "User-Agent" stammt aus der HTTP-Spezifikation, wo er sich auf die Client-Anwendung bezieht, die eine Anfrage an einen Webserver stellt.

Frühe Tage (1990er)

Der erste weit verbreitete Browser, NCSA Mosaic, enthielt einen einfachen User-Agent-String, der den Browsernamen und die Version identifizierte. Als Netscape Navigator veröffentlicht wurde, verwendete er ein ähnliches Format. Als Webserver jedoch begannen, unterschiedliche Inhalte basierend auf dem Browser bereitzustellen, entstand eine Praxis, die als "Browser-Sniffing" bekannt ist.

Die Browserkriege und User-Agent-Spoofing (späte 1990er)

Während der Browserkriege zwischen Netscape und Internet Explorer boten Websites oft optimierte Inhalte ausschließlich für bestimmte Browser an. Um die Kompatibilität sicherzustellen, begannen Browser, Strings einzuschließen, die sie als andere Browser identifizierten. Aus diesem Grund enthalten die meisten modernen Browser immer noch "Mozilla" in ihren User-Agent-Strings, ein Verweis auf den Codenamen von Netscape Navigator.

Mobile Revolution (2000er-2010er)

Der Aufstieg mobiler Geräte brachte neue Komplexität in die User-Agent-Strings. Mobile Browser mussten sich als mobil identifizieren, um geeignete Inhalte zu erhalten, was zur Hinzufügung von Gerätebezeichnern und mobil spezifischen Tokens führte.

Moderne Herausforderungen (2010er bis heute)

Da das Web-Ökosystem komplexer geworden ist, sind User-Agent-Strings zunehmend verworren. Sie enthalten nun Verweise auf mehrere Browser-Engines (wie "AppleWebKit" und "Gecko") aus Kompatibilitätsgründen, selbst wenn diese Engines nicht tatsächlich verwendet werden.

Diese Komplexität hat zu Herausforderungen bei der genauen Analyse von User-Agent-Strings geführt, und einige Webstandardsgruppen haben vorgeschlagen, User-Agent-Strings abzulehnen oder zu vereinfachen, zugunsten strukturierterer Client-Hinweise. Aus Gründen der Rückwärtskompatibilität bleibt der traditionelle User-Agent-String jedoch ein wesentlicher Bestandteil des Web-Browsings.

Codebeispiele

Hier sind Beispiele, wie man mit User-Agent-Strings in verschiedenen Programmiersprachen arbeitet:

1// JavaScript: Erkennen des Browser-Typs aus dem 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 "Unbekannt";
21  }
22}
23
24// Verwendung
25console.log("Sie verwenden: " + detectBrowser());
26

1# Python: Benutzerdefinierten User-Agent in Anfragen festlegen
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# Beispielverwendung
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100])  # Die ersten 100 Zeichen der Antwort drucken
15

1<?php
2// PHP: Erkennen mobiler Geräte anhand des 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// Verwendung
16if (isMobileDevice()) {
17    echo "Sie verwenden ein mobiles Gerät.";
18} else {
19    echo "Sie verwenden ein Desktop-Gerät.";
20}
21?>
22

1// Java: Generierung eines zufälligen User-Agent
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, wie 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: Analysieren des User-Agent-Strings
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# Beispielverwendung
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, wie Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
21

1// C#: Benutzer-Agent in HttpClient festlegen
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8    static async Task Main()
9    {
10        // HttpClient mit benutzerdefiniertem User-Agent erstellen
11        using (var httpClient = new HttpClient())
12        {
13            string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/96.0.4664.110 Safari/537.36";
14            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15            
16            try
17            {
18                // Anfrage mit benutzerdefiniertem User-Agent senden
19                HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20                response.EnsureSuccessStatusCode();
21                string responseBody = await response.Content.ReadAsStringAsync();
22                
23                Console.WriteLine($"Antwort erhalten mit Statuscode: {response.StatusCode}");
24                Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Die ersten 100 Zeichen
25            }
26            catch (HttpRequestException e)
27            {
28                Console.WriteLine($"Anfragefehler: {e.Message}");
29            }
30        }
31    }
32}
33

1// Go: HTTP-Anfragen mit benutzerdefinierten User-Agents erstellen
2package main
3
4import (
5    "fmt"
6    "io/ioutil"
7    "net/http"
8)
9
10func main() {
11    // Eine neue Anfrage erstellen
12    req, err := http.NewRequest("GET", "https://example.com", nil)
13    if err != nil {
14        fmt.Printf("Fehler beim Erstellen der Anfrage: %s\n", err)
15        return
16    }
17    
18    // Benutzerdefinierten User-Agent festlegen
19    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/96.0.4664.110 Safari/537.36")
20    
21    // Die Anfrage senden
22    client := &http.Client{}
23    resp, err := client.Do(req)
24    if err != nil {
25        fmt.Printf("Fehler beim Senden der Anfrage: %s\n", err)
26        return
27    }
28    defer resp.Body.Close()
29    
30    // Die Antwort lesen
31    body, err := ioutil.ReadAll(resp.Body)
32    if err != nil {
33        fmt.Printf("Fehler beim Lesen der Antwort: %s\n", err)
34        return
35    }
36    
37    fmt.Printf("Antwortstatus: %s\n", resp.Status)
38    fmt.Printf("Vorschau des Antwortinhalts: %s\n", body[:100])
39}
40

Häufige User-Agent-Muster

Hier sind einige Beispiele für echte User-Agent-Strings für verschiedene Browser und Plattformen:

Desktop-Browser

Chrome unter Windows:

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

Firefox unter macOS:

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

Safari unter macOS:

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

Edge unter Windows:

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

Mobile-Browser

Chrome unter Android:

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

Safari auf iPhone:

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

Firefox unter Android:

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

Samsung Internet auf Galaxy:

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

Referenzen

"User Agent." MDN Web Docs, Mozilla, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
"Browser User Agent Strings." WhatIsMyBrowser.com, https://www.whatismybrowser.com/guides/the-latest-user-agent/
"HTTP User-Agent Header Explained." 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
"Geschichte des User-Agent-Strings." WebAIM, https://webaim.org/blog/user-agent-string-history/
"Browsererkennung mit dem User-Agent." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/

Whiz Tools

Zufälliger User-Agent-Generator für Webentwicklungstests

Zufälliger Benutzeragent-Generator

Generierter Benutzeragent

Dokumentation