Willekeurige User Agent Generator voor Webontwikkeling Testen

Willekeurige User Agent Generator

Inleiding

Een User Agent-string is een specifieke tekstidentificatie die webbrowsers en andere applicaties naar websites sturen om zichzelf te identificeren. Deze string bevat doorgaans informatie over de browser, het besturingssysteem, het apparaattype en de rendering-engine die wordt gebruikt. Voor webontwikkelaars en testers is toegang tot een verscheidenheid aan realistische user agent-strings essentieel voor het testen van de compatibiliteit, responsiviteit en functionaliteit van websites op verschillende platforms.

Deze Willekeurige User Agent Generator-tool creëert authentiek uitziende user agent-strings op basis van uw geselecteerde parameters. U kunt filteren op apparaattype (desktop of mobiel), browserfamilie (Chrome, Firefox, Safari of Edge) en besturingssysteem om user agents te genereren die passen bij uw testvereisten. De tool biedt een eenvoudige interface met opties om de gegenereerde string met één klik te kopiëren en nieuwe willekeurige strings onmiddellijk te genereren.

User Agent-structuur

User agent-strings volgen specifieke patronen afhankelijk van de browser en het platform, maar bevatten over het algemeen verschillende gemeenschappelijke componenten:

Browseridentificatie: Begint meestal met "Mozilla/5.0" om historische compatibiliteitsredenen
Platform/OS-informatie: Gegevens over het besturingssysteem (Windows, macOS, Android, iOS)
Browserengine: De rendering-engine (zoals Gecko, WebKit of Blink)
Browserdetails: De specifieke browsernaam en versie

Hier is een overzicht van typische user agent-structuren voor belangrijke browsers:

Chrome

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

Firefox

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

Safari

1Mozilla/5.0 (platform) AppleWebKit/webkitversion (KHTML, zoals Gecko) Versie/safariversie Safari/safariversie
2

Edge

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

De platformsectie varieert aanzienlijk tussen desktop- en mobiele apparaten:

Desktop Voorbeelden:

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

Mobiele Voorbeelden:

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

Verschillen in apparaattype

Desktop User Agents

Desktop user agents bevatten doorgaans specifieke informatie over het besturingssysteem, architectuurdetails (zoals x86_64 of Win64) en soms taalvoorkeuren. Ze zijn doorgaans consistenter tussen browsers dan mobiele user agents.

Mobiele User Agents

Mobiele user agents bevatten informatie over het apparaatsmodel, versies van mobiele besturingssystemen en bevatten vaak het woord "Mobile" aan het einde. Mobiele Safari op iOS-apparaten zal "iPhone" of "iPad" identificaties bevatten, terwijl Android-apparaten de fabrikant en het modelnummer bevatten.

Browserversiepatronen

Elke browser volgt verschillende versiepatronen:

Chrome: Gebruikt vierdelige versienummers (bijv. 96.0.4664.110)
Firefox: Gebruikt doorgaans twee of driedelige versienummers (bijv. 95.0 of 95.0.2)
Safari: Gebruikt eenvoudige versienummers zoals 15.2
Edge: Gebruikt versienummers die vergelijkbaar zijn met Chrome, maar met zijn eigen Edge-versie (bijv. 96.0.1054.62)

Toepassingen

Willekeurige user agent-generatie heeft verschillende belangrijke toepassingen in webontwikkeling en testen:

Cross-Browser Compatibiliteitstest: Test hoe uw website wordt weergegeven en functioneert op verschillende browsers zonder dat u meerdere browsers hoeft te installeren of meerdere apparaten hoeft te gebruiken.
Responsieve Ontwerptest: Controleer of uw website correct mobiele en desktopapparaten detecteert en de juiste lay-out serveert.
Validatie van Functiedetectie: Zorg ervoor dat de functiedetectiemechanismen van uw website correct werken voor verschillende browsermogelijkheden.
QA en Geautomatiseerde Tests: Neem verschillende user agents op in uw geautomatiseerde testscripts om verschillende gebruikersomgevingen te simuleren.
Prestatie-testen: Analyseer hoe uw website presteert wanneer deze wordt benaderd vanuit verschillende browseromgevingen.
Foutenopsporing van browser-specifieke problemen: Reproduceer en los bugs op die alleen optreden in specifieke browsers of versies.
API-testen: Test hoe uw API omgaat met verzoeken van verschillende clientapplicaties.

Alternatieven

Hoewel onze willekeurige user agent-generator nuttig is voor veel testscenario's, zijn er alternatieve benaderingen:

Browser Testdiensten: Platforms zoals BrowserStack, Sauce Labs of LambdaTest bieden daadwerkelijke browserinstanties voor testen in plaats van alleen de user agent te simuleren.
Browser Ontwikkelaarstools: De meeste moderne browsers stellen u in staat om de user agent te overschrijven via hun ontwikkelaarstools, wat nuttig kan zijn voor snelle tests.
User Agent Switcher-extensies: Browserextensies waarmee u tussen vooraf gedefinieerde user agents kunt schakelen tijdens het browsen.
Virtuele Machines of Containers: Het draaien van daadwerkelijke instanties van verschillende besturingssystemen en browsers voor de meest nauwkeurige tests.
Headless Browser Testing: Het gebruik van tools zoals Puppeteer of Selenium om browsers programmatisch te besturen met verschillende user agent-instellingen.

Elke alternatieve heeft zijn eigen voordelen en kan geschikter zijn, afhankelijk van uw specifieke testbehoeften en middelen.

Geschiedenis

Het concept van de user agent-string dateert uit de vroege dagen van het World Wide Web. De term "user agent" komt uit de HTTP-specificatie, waar het verwijst naar de clienttoepassing die een verzoek doet aan een webserver.

Vroege Dagen (1990s)

De eerste veelgebruikte browser, NCSA Mosaic, bevatte een eenvoudige user agent-string die de browsernaam en versie identificeerde. Toen Netscape Navigator werd uitgebracht, gebruikte het een vergelijkbaar formaat. Toen webservers begonnen met het leveren van verschillende inhoud op basis van de browser, ontstond een praktijk die bekend staat als "browser sniffing".

De Browseroorlogen en User Agent Spoofing (Eind 1990s)

Tijdens de browseroorlogen tussen Netscape en Internet Explorer, dienden websites vaak geoptimaliseerde inhoud exclusief aan specifieke browsers. Om compatibiliteit te waarborgen, begonnen browsers strings op te nemen die zichzelf als andere browsers identificeerden. Dit is de reden waarom de meeste moderne browsers nog steeds "Mozilla" in hun user agent-strings opnemen, een verwijzing naar de codenaam van Netscape Navigator.

Mobiele Revolutie (2000s-2010s)

De opkomst van mobiele apparaten introduceerde nieuwe complexiteit in user agent-strings. Mobiele browsers moesten zichzelf als mobiel identificeren om de juiste inhoud te ontvangen, wat leidde tot de toevoeging van apparaatsidentificaties en mobiele specifieke tokens.

Moderne Uitdagingen (2010s-Heden)

Naarmate het webecosysteem complexer werd, zijn user agent-strings steeds ingewikkelder geworden. Ze bevatten nu verwijzingen naar meerdere browserengines (zoals "AppleWebKit" en "Gecko") om compatibiliteitsredenen, zelfs wanneer die engines niet daadwerkelijk worden gebruikt.

Deze complexiteit heeft geleid tot uitdagingen bij het nauwkeurig parseren van user agent-strings, en sommige webstandaardgroepen hebben voorgesteld om user agent-strings te deprecateren of te vereenvoudigen ten gunste van meer gestructureerde client hints. Echter, om redenen van achterwaartse compatibiliteit, blijft de traditionele user agent-string een essentieel onderdeel van web browsen.

Code Voorbeelden

Hier zijn voorbeelden van hoe u met user agent-strings kunt werken in verschillende programmeertalen:

1// JavaScript: Detecteren van het browsertype vanuit 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 "Onbekend";
21  }
22}
23
24// Gebruik
25console.log("U gebruikt: " + detectBrowser());
26

1# Python: Instellen van een aangepaste user agent in 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# Voorbeeldgebruik
12chrome_ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, zoals Gecko) Chrome/96.0.4664.110 Safari/537.36'
13content = fetch_with_user_agent('https://example.com', chrome_ua)
14print(content[:100])  # Print de eerste 100 tekens van de reactie
15

1<?php
2// PHP: Detecteren van mobiele apparaten met behulp van 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// Gebruik
16if (isMobileDevice()) {
17    echo "U gebruikt een mobiel apparaat.";
18} else {
19    echo "U gebruikt een desktopapparaat.";
20}
21?>
22

1// Java: Genereren van een willekeurige 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, zoals 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: Parseren van user agent-string
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# Voorbeeldgebruik
18ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, zoals Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1'
19info = parse_user_agent(ua)
20puts info
21

1// C#: Instellen van user agent in HttpClient
2using System;
3using System.Net.Http;
4using System.Threading.Tasks;
5
6class Program
7{
8    static async Task Main()
9    {
10        // Maak HttpClient met aangepaste user agent
11        using (var httpClient = new HttpClient())
12        {
13            string userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, zoals Gecko) Chrome/96.0.4664.110 Safari/537.36";
14            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
15            
16            try
17            {
18                // Maak verzoek met aangepaste user agent
19                HttpResponseMessage response = await httpClient.GetAsync("https://example.com");
20                response.EnsureSuccessStatusCode();
21                string responseBody = await response.Content.ReadAsStringAsync();
22                
23                Console.WriteLine($"Reactie ontvangen met statuscode: {response.StatusCode}");
24                Console.WriteLine(responseBody.Substring(0, 100) + "..."); // Eerste 100 tekens
25            }
26            catch (HttpRequestException e)
27            {
28                Console.WriteLine($"Verzoekfout: {e.Message}");
29            }
30        }
31    }
32}
33

1// Go: HTTP-verzoeken maken met aangepaste user agents
2package main
3
4import (
5    "fmt"
6    "io/ioutil"
7    "net/http"
8)
9
10func main() {
11    // Maak een nieuw verzoek
12    req, err := http.NewRequest("GET", "https://example.com", nil)
13    if err != nil {
14        fmt.Printf("Fout bij het maken van verzoek: %s\n", err)
15        return
16    }
17    
18    // Stel aangepaste user agent in
19    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, zoals Gecko) Chrome/96.0.4664.110 Safari/537.36")
20    
21    // Stuur het verzoek
22    client := &http.Client{}
23    resp, err := client.Do(req)
24    if err != nil {
25        fmt.Printf("Fout bij het verzenden van verzoek: %s\n", err)
26        return
27    }
28    defer resp.Body.Close()
29    
30    // Lees de reactie
31    body, err := ioutil.ReadAll(resp.Body)
32    if err != nil {
33        fmt.Printf("Fout bij het lezen van reactie: %s\n", err)
34        return
35    }
36    
37    fmt.Printf("Reactiestatus: %s\n", resp.Status)
38    fmt.Printf("Voorbeeld van de reactie-inhoud: %s\n", body[:100])
39}
40

Veelvoorkomende User Agent-patronen

Hier zijn enkele voorbeelden van echte user agent-strings voor verschillende browsers en platforms:

Desktop Browsers

Chrome op Windows:

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

Firefox op macOS:

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

Safari op macOS:

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

Edge op Windows:

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

Mobiele Browsers

Chrome op Android:

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

Safari op iPhone:

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

Firefox op Android:

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

Samsung Internet op Galaxy:

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

Referenties

"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
"Geschiedenis van de browser user-agent-string." WebAIM, https://webaim.org/blog/user-agent-string-history/
"Browserdetectie met behulp van de User Agent." Google Developers, https://developer.chrome.com/docs/multidevice/user-agent/

Whiz Tools

Willekeurige User Agent Generator voor Webontwikkeling Testen

Willekeurige User Agent Generator

Gegenereerde User Agent

Documentatie