De eerste keer dat ik een User-Agent-string in bulk moest begrijpen, was tijdens een SEO-project wpadminify.com, starend naar een servertoegangslogboek om erachter te komen hoeveel van het verkeer echte mensen waren en hoeveel crawlers. Ik had een kolom met tekenreeksen waarmee alles begon Mozilla/5.0, allemaal genoemd Safari, en de helft van hen loog over het zijn van de ene browser terwijl eigenlijk de andere was Het lezen ervan met het oog was hopeloos Dat is het werk dat een User-Agent parser doet, en nadat ik het te vaak op de harde manier heb gedaan, heb ik er een ingebouwd Toolz.dev. Dit is de leidraad ervoor, en voor de verrassend rommelige kop erachter.
tl;dr: De Toolz user agent parser neemt een User-Agent string en splitst deze in browser, rendering engine, besturingssysteem, apparaat type, en CPU architectuur Het past de detectie order de header' s quirks eisen, dus Edge wordt niet verkeerd gelezen als Chrome en mobiele Safari wordt gelezen van zijn echte versie token Het markeert ook bekende bots Alles draait client-side: geen upload, geen aanmelding, veilig voor echte log lijnen.
Wat is een User-Agent string?
Een User-Agent string is de waarde van de User-Agent vraagheader die een browser of HTTP-client met bijna elk verzoek verzendt De header is gedefinieerd in RFC 9110, de HTTP Semantics-specificatie, die het beschrijft als een reeks productidentificatoren en opmerkingen waarmee een server de software kan identificeren die het verzoek doet. In de praktijk noemt het de browser, de versie ervan, de rendering-engine, het besturingssysteem en vaak het apparaat.
De bedoeling was redelijk: geef servers een manier om te weten wat er verbinding maakt, zodat ze reacties kunnen aanpassen of statistieken kunnen verzamelen. De realiteit is dat de string een van de minst betrouwbare stukjes zelfgerapporteerde gegevens op internet is geworden, niet omdat deze kwaadaardig is, maar omdat twintig jaar compatibiliteitshacks token op token hebben gelaagd totdat de voor de hand liggende lezing meestal de verkeerde is.
Hier is een moderne Chrome-tekenreeks op Windows:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36
Het beweert Mozilla te zijn, noemt AppleWebKit, en eindigt met het woord Safari Het is geen van die dingen; het is Chrome Elk token eerder Chrome/126 is historisch sediment Een parser bestaat juist omdat je de tokens die er het meest gezaghebbend uitzien niet kunt vertrouwen.
Waarom is het parseren van een User-Agent zo foutgevoelig?
De header groeide door imitatie In de vroege browseroorlogen controleerden servers de User-Agent om te beslissen welke versie van een pagina ze moesten verzenden, en ze controleerden onhandig, vaak met een eenvoudige substring match Een nieuwe browser die de goede, moderne pagina wilde ontvangen moest het token bevatten waar de server naar op zoek was, dus elke browser kopieerde zichzelf Mozilla, dus Internet Explorer beweerde Mozilla-compatibel te zijn Toen WebKit-browsers arriveerden droegen ze de Mozilla - en KHTML-tokens Chrome splitste zich af van WebKit en hield zowel AppleWebKit als Safari zodat WebKit-sniffing servers het goed zouden behandelen Het resultaat is dat een enkele can-string eerlijk de lijn van vier bevat
Zo ontstaan er concrete vallen voor iedereen die het touwtje leest
- Edge en Opera bevatten beide
Chrome. Microsoft Edge voegt toeEdg/126.0.0.0en Opera voegt eraan toeOPR/, maar beide dragen ook het volledigeChrome/126token omdat ze Chromium-gebaseerd zijn Test eerst voor Chrome en je zal elke Edge en Opera gebruiker als Chrome bestempelen. - Safari verbergt zijn echte versie. Op de desktop en op iOS rapporteert Safari zijn gebruikersgerichte versie in een
Version/17.5token, terwijl deSafari/604.1token aan het einde is het WebKit build nummer, niet de browser versie LeesSafari/als de versie en je krijgt een nietszeggend getal. - Chrome op iOS is geen Chrome's-engine. Apple vereist dat alle iOS-browsers WebKit gebruiken, dus Chrome op een iPhone rapporteert
CriOSen draait WebKit, niet Blink. Firefox op iOS isFxiOS, ook WebKit. - Windows 11 bestaat niet in de tekenreeks. Microsoft heeft het NT-kerneltoken nooit gestoten, dus zowel Windows 10 als Windows 11 rapporteren
Windows NT 10.0. De snaar kan ze helemaal niet uit elkaar houden.
Een parser is een kleine stapel geordende regels die van deze vallen op de hoogte zijn Dat is echt alles wat het is, maar de volgorde goed krijgen is het hele spel.
Hoe werkt de Toolz user agent parser?
de parser voert een reeks controles waarvan de orde codeert de vallen hierboven Het zoekt naar de browsers die een andere browser en#39; s eerst token insluiten Edge vóór Chrome, Opera vóór Chrome, Samsung Internet en UC Browser vóór Chrome, dus de geleende Chrome token wint nooit per ongeluk Het leest Safari uit zijn Version/ token in plaats van zijn Safari/ build-token. Het herkent de iOS-varianten CriOS en FxiOS als respectievelijk Chrome en Firefox terwijl hun engine correct wordt gerapporteerd als WebKit.
Voor het besturingssysteem wijst het het Windows NT-kernelnummer toe aan de marketingnaam, dus Windows NT 6.1 wordt Windows 7 en Windows NT 10.0 wordt Windows 10 of 11, eerlijk gezegd als een paar omdat de string ze echt niet kan onderscheiden. Het herstelt de gestippelde vorm van iOS- en macOS-versies, die de header schrijft met onderstrepingstekens zoals 17_5, en het herkent Android, Chrome OS en Linux.
Voor het apparaat classificeert het het verzoek als desktop, mobiel, tablet of bot. De tabletregel is de onhandige: een iPad is een tablet, een Android-apparaat zonder de Mobile token is een tablet en alles wat daarbij past Mobile, iPhone, of Windows Phone is een telefoon Waar de string een apparaatmodel blootlegt, zoals een Android-buildstring of een Apple-productnaam, komt de parser er boven.
Het markeert ook bots. Dit is het veld dat ik voor de meesten bereik, want als je een toegangslogboek leest, is de nuttigste vraag hoeveel van het verkeer geautomatiseerd is. De parser komt overeen met een brede reeks handtekeningen die betrekking hebben op zoekcrawlers, het ophalen van sociale previews en opdrachtregelclients.
Wat kan een User-Agent u vertellen, en wat niet?
Het is de moeite waard om precies te zijn over de grenzen, omdat het behandelen van de string als feit tot slechte beslissingen leidt.
| Question | Kan de UA het beantwoorden? | vastleggen |
|---|---|---|
| Welke browser familie | Meestal wel | Met correcte detectievolgorde |
| Exacte browserversie | Meestal wel | Steeds vaker bevroren of gereduceerd |
| Naam besturingssysteem | Meestal wel | Windows 10 vs 11 is onmogelijk |
| Apparaattype | Grofweg | Heuristisch, niet gegarandeerd |
| Exact apparaat model | Soms | Alleen als de string het bevat |
| Of de cliënt oprecht is | heel weinig | Triviaal spoofabel |
| Schermgrootte of mogelijkheden | heel weinig | Gebruik in plaats daarvan functiedetectie |
De laatste twee rijen doen er het meest toe Een User-Agent wordt zelf gerapporteerd en kan worden gewijzigd in één regel code, ingesteld door elke HTTP-client, of bevroren door de browser voor privacy Een scraper kan zichzelf aankondigen als Chrome op Windows en er is niets in de string dat dit tegenspreekt Dus het geparseerde resultaat vertelt je wat de client beweert te zijn, wat handig is voor statistieken en foutopsporing, maar geen bewijs van iets Wanneer je moet weten wat een browser daadwerkelijk kan doen, feature-detecteren in JavaScript in plaats van mogelijkheden af te leiden uit de naam Dit is hetzelfde principe achter het schrijven van veerkrachtige front-end code dat de Webontwikkelaar Toolkit roundup keert herhaaldelijk terug naar.
Gaan User-Agent strings weg?
Niet precies, maar ze worden bewust gereduceerd Chromium browsers bevriezen en trimmen de legacy string al een paar jaar, en beperken het detailniveau dat het blootlegt, met name de kleine versienummers en enkele platformspecificaties De vervanging is User-Agent Client-tips, een mechanisme waarbij de server precies vraagt naar de stukjes clientinformatie die hij nodig heeft Sec-CH-UA headers aanvragen en de navigator.userAgentData JavaScript API, in plaats van het ontvangen van één lange string het moet parseren Client Hints is ook waar de Windows 10 versus 11 onderscheid eindelijk beschikbaar komt, door Sec-CH-UA-Platform-Version.
Het praktische resultaat voor de komende jaren is dat beide bestaan. De klassieker User-Agent header wordt nog steeds verzonden op elk verzoek van elke browser en elke niet-browserclient, en veel tooling, analyses en logica aan de serverzijde leest het nog steeds. Het parseren van de string blijft dus de meest draagbare manier om een client te identificeren, zelfs als de rijkere gegevens naar clienthints gaan. Als u iets nieuws bouwt en de platformversie precies wilt, lees dan Clienthints; als u een bestaand logboek analyseert of het grootste aantal clients ondersteunt, parseer dan de string.
Hoe gebruik ik de parser?
De stroom is bewust eenvoudig Plak een User-Agent string in het vak, of klik op een van de ingebouwde samples om een representatieve desktop, mobiel, of bot string te zien Om je eigen te pakken, open je browser console en type navigator.userAgent, plak dan het resultaat Terwijl u typt, worden de browser, engine, besturingssysteem, apparaattype, CPU-architectuur en botvlag live bijgewerkt, zonder dat u op de knop hoeft te drukken Wanneer u het resultaat elders wilt, kopieert u het als een tabel met tabs die netjes in een spreadsheet of een bugrapport past.
Omdat het geheel in uw browser draait, kunt u onbewerkte toegangs-logregels of echte bezoekersreeksen plakken zonder dat een van deze uw machine verlaat Dat model aan de clientzijde is opzettelijk en is achter elk hulpmiddel op de site hetzelfde, uitgelegd in de online tools voor gegevensprivacy gids. Voor een inloggegevens debugt u naast een verzoek, de basisauth generator en de JWT decoder volg dezelfde no-upload aanpak.
Waar de parser past bij de andere webtools
De user agent parser zit in een klein cluster van request-and-response tools op de site Wanneer u het verkeer naar een domein inspecteert, wordt de domein zoeken tool antwoordt wie het bezit en exploiteert Wanneer een verzoek een dragertoken draagt dat u moet inspecteren, moet de JWT decoder leest de claims eruit Wanneer u in de eerste plaats een geauthenticeerd verzoek construeert, wordt de basisauth generator bouwt de Authorization koptekst. En wanneer u werkt aan hoe een pagina zich presenteert aan crawlers, die uw pagina's lezen onder hun eigen gebruikersagenten, zal de meta tag generator vormt de tags die ze consumeren.
Voor iedereen die een persoonlijke set hiervan samenstelt, is de Productiviteitstools voor ontwikkelaar gids behandelt hoe de browser-gebaseerde hulpprogramma's op de site passen in een werkdag Het punt van het bij elkaar houden is dat het debuggen van een HTTP-interactie zelden slechts één van deze vragen omvat.
Een praktische workflow: het lezen van een verkeerslogboek
Laat me dit concreet maken met de taak die me op deze weg begon Je hebt een stukje van je toegangslog geëxporteerd en je wilt het begrijpen De naïeve benadering is om naar de User-Agent kolom te kijken, dat is precies waar de vallen bijten Een crawler die zich beleefd identificeert als Googlebot is makkelijk, maar een headless scraper die zichzelf aankondigt als een normale Chrome build ziet er identiek uit als een echte bezoeker totdat je de andere signalen controleert.
De parser helpt op twee manieren Ten eerste vangt de botvlag de eerlijke crawlers en de gangbare automatiseringsclients onmiddellijk op, zodat u het voor de hand liggende machineverkeer in één keer kunt scheiden van het menselijke verkeer. Ten tweede vertelt de juiste browser- en OS-storing van het resterende verkeer u iets echts over uw publiek: of het mobiel scheeftrekt, welke besturingssystemen domineren, of een oude browser er nog steeds genoeg toe doet om tegen te testen. Op het WP Adminify-werk veranderde die storing welke browsers we prioriteit gaven voor testen en bevestigde dat een deel van wat op organisch verkeer leek preview- en monitoringbots was in plaats van lezers. Door de strings te parseren, werd een muur van ruis een beslissing gemaakt.
De enige discipline die je moet behouden is die van de limietensectie: het geparseerde resultaat is een claim, geen bewijs. Een bepaalde scraper zal een overtuigende string smeden, en geen enkele parser kan die alleen van de User-Agent opvangen. Combineer de parse met verzoekpatronen, snelheid en andere signalen wanneer de inzet hoog is. Voor alledaagse statistieken en foutopsporing is een correcte parse echter precies wat je nodig hebt, en het met de hand doen is de fout.
Wat vertellen de rendering engine en CPU velden mij?
Twee van de geparseerde velden krijgen minder aandacht dan de browser en OS, maar beide zijn nuttig De rendering engine is de component die HTML en CSS daadwerkelijk in pixels verandert, en het is een betere voorspeller van hoe een pagina zich gedraagt dan de browsernaam Chrome, Edge, Opera, Brave, Samsung Internet, en de meeste anderen delen de Blink engine, dus een rendering bug die in een verschijnt verschijnt meestal in alle van hen; Firefox gebruikt Gecko; en Safari, samen met elke browser op iOS, maakt gebruik van WebKit Wanneer u een lay-out bug uitprobeert, groepeert u uw verkeer per engine in plaats van op browsernaam u hoeveel echt verschillende rendering paden u moet testen, die vaak is slechts drie.
De parser leidt de engine af van de platformtokens in plaats van het browserlabel, daarom kan hij Blink rapporteren voor een Chromium-browser en WebKit voor Safari, ook al stammen beide af van hetzelfde AppleWebKit-token. Het vangt ook de oudere engines, Trident voor Internet Explorer en EdgeHTML voor legacy Edge, die nog steeds in bedrijfslogboeken verschijnen.
Het CPU-architectuurveld leest de platformtokens voor x86_64, Win64, arm64, en hun familieleden, die rapporteren of de client een 64-bit, 32-bit of ARM-machine is Het is het veld om te controleren wanneer u platformspecifieke downloads aanbiedt en moet weten welke build een bezoeker kan uitvoeren, en het is een stil signaal van hoe modern uw publiek en #39;s hardware is.
Veelgestelde vragen
Wat is een User-Agent string? Een User-Agent string is de waarde van de User-Agent HTTP header die een browser of client bij elk verzoek verzendt Het is een lijst van producttokens met de naam van de browser, de rendering engine, het besturingssysteem, en vaak het apparaat, gedefinieerd in RFC 9110 Servers lezen het om de software te identificeren die er verbinding mee maakt.
Hoe vind ik mijn eigen User-Agent? Open uw browser' s ontwikkelaarsconsole en typ navigator.userAgent, druk vervolgens op Enter De tekenreeks die het afdrukt is precies wat uw browser naar servers stuurt Plak het in de user agent parser om de browser, het besturingssysteem en het apparaat te zien waarnaar het decodeert.
Waarom bevat Chrome's User-Agent het woord Safari? Voor achterwaartse compatibiliteit Chrome heeft zijn engine afgesplitst van Apple's WebKit, en vroege servers controleerden op het Safari-token voordat ze moderne pagina's bedienden, dus Chrome behield het om te voorkomen dat het werd gedegradeerd. Dezelfde geschiedenis is de reden waarom bijna elke browser nog steeds zijn string begint met Mozilla/5.0.
Kan een User-Agent Windows 10 vertellen vanuit Windows 11? Nee. Beiden rapporteren Windows NT 10.0 omdat Microsoft nooit het NT-kerneltoken voor Windows 11 heeft verhoogd, zodat de string alleen de twee niet kan onderscheiden. De moderne manier om ze uit elkaar te houden is User-Agent Client Hints, met name de Sec-CH-UA-Platform-Version-header.
Is een User-Agent betrouwbaar voor het identificeren van een apparaat? Het is een nuttige hint, geen bewijs User-Agents kunnen worden gewijzigd in één regel code, ingesteld door elke HTTP-client, vervalst door scrapers of bevroren door de browser voor privacy Behandel het geparseerde resultaat als wat de client beweert te zijn, en combineer het met andere signalen wanneer nauwkeurigheid van belang is.
Hoe detecteert de parser bots en crawlers? Het koppelt de string aan een brede lijst met bekende handtekeningen, waaronder zoekcrawlers zoals Googlebot en Bingbot, het ophalen van sociale previews en automatiseringsclients zoals curl, wget en headless Chrome. Elke match stelt de botvlag in en classificeert het apparaat als een crawler.
Is het veilig om productielogboek User-Agents hier te plakken? Ja Alle parsering gebeurt in uw browser met JavaScript, en de string wordt nooit naar een server verzonden U kunt onbewerkte access-log-regels of echte bezoeker-User-Agents plakken zonder dat ze uw apparaat verlaten.
Worden User-Agent-strings verouderd? De header wordt bevroren en verkleind, niet verwijderd Chromium-browsers sluiten nu de details af in de oudere tekenreeks en leggen rijkere gegevens bloot via User-Agent Client Hints. De klassieke tekenreeks wordt nog steeds op elk verzoek verzonden, dus het parseren ervan blijft de meest draagbare manier om clientgegevens te lezen.
