User-Agent Parser - Browser, OS, Device and Bot Detection, in Bulk

Turn raw User-Agent strings into structured fields: browser and version, operating system, device type and vendor, rendering engine, CPU architecture - plus an isBot verdict covering search crawlers, AI training crawlers, SEO tools, social preview fetchers, HTTP libraries and uptime monitors. Up to 1,000 UAs per run. $0.0004 per string. Implausible strings are recorded free.

Log analysis, traffic-quality audits, analytics enrichment, filtering bots out before you bill for traffic: they all start with "what actually sent this request?"

What you get

Per string, one record with these exact fields:

• ok - true when the string was parsed
• userAgent - the string you sent
• browser - name, version, major
• os - name, version
• device - vendor, model, type (mobile, tablet, console, smarttv, wearable, embedded)
• engine - name, version
• cpu - architecture
• isBot - boolean
• error - present instead of the fields when the string was not a plausible UA. Never charged.

Unmatched fields come back as null, never missing, so the record shape is stable across every row.

Example 1: a real mobile browser

Input:

{ "userAgent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1" }

Output (real run, 2026-08-15):

{
  "ok": true,
  "browser": { "name": "Mobile Safari", "version": "17.5", "major": "17" },
  "os": { "name": "iOS", "version": "17.5" },
  "device": { "vendor": "Apple", "model": "iPhone", "type": "mobile" },
  "engine": { "name": "WebKit", "version": "605.1.15" },
  "cpu": { "architecture": null },
  "isBot": false
}

Example 2: an AI crawler and a command-line client

Input:

{
  "userAgents": [
    "Mozilla/5.0 (compatible; GPTBot/1.1; +https://openai.com/gptbot)",
    "curl/8.4.0"
  ]
}

Output (real run, same session, trimmed):

[
  { "userAgent": "Mozilla/5.0 (compatible; GPTBot/1.1; +https://openai.com/gptbot)", "ok": true, "isBot": true,
    "browser": { "name": null, "version": null, "major": null }, "os": { "name": null, "version": null } },
  { "userAgent": "curl/8.4.0", "ok": true, "isBot": true,
    "browser": { "name": null, "version": null, "major": null }, "os": { "name": null, "version": null } }
]

Both are flagged isBot: true even though neither carries a browser or OS to parse - that is the curated signature list doing the work the parsing library alone would not.

When userAgents is filled, the single userAgent field is ignored - you are charged for the strings you listed and nothing else.

Example 3: enriching a log file

Input:

{ "userAgents": ["...UA from line 1...", "...UA from line 2...", "..."], "maxItems": 1000 }

One record and one charge per string, up to 1,000 per run. Join the results back onto your log rows by the userAgent field, then split on isBot to separate real traffic from crawlers.

Pricing

$0.0004 per User-Agent parsed. No start fee. One event covers one string parsed into every field above plus the bot verdict. Strings that are not plausible User-Agents (under 3 characters, or containing control characters) are recorded as ok: false and never charged, so a log file with mangled rows only bills for the rows that parsed.

Enriching 10,000 log lines costs $4.

Honest comparison: on 2026-08-07 a store search for "user agent parser" and "ua parser" returned scrapers rather than parsers - there was no directly comparable paid incumbent to quote a price against, so this is priced at the floor of our ladder rather than against a competitor.

Also honest: ua-parser-js is a free open-source library, and it is exactly what this Actor uses. If you already run Node or Python, parsing locally costs nothing. Pay for this when you want it as a hosted step, in bulk, inside a no-code pipeline, or as a tool an AI agent can call - and for the isBot list, which the library does not give you.

When NOT to use this

• Detecting adversarial bots. A scraper that sends a perfect Chrome User-Agent is indistinguishable from Chrome by string alone. No UA parser can fix a lying client. Combine with IP reputation, rate patterns and behavioural signals for anything adversarial. This catches the honest bots - which is most crawler traffic.
• Getting exact browser versions from modern Chrome. Chrome freezes its UA version. Fine-grained version and platform data live in Client Hints headers (Sec-CH-UA-*), which are not part of the UA string and cannot be recovered from it.
• Device model detail for desktops. Desktop UAs legitimately carry no device type, vendor or model - the spec only marks mobile, tablet and similar explicitly. null there is correct, not a parse failure.
• Brand-new browser releases on day one. Parsing follows the pinned library version, so a browser released after it can land as an unknown until the library updates.
• A handful of strings, once. Free web parsers exist for that. This is for volume.

Honest limits

• Parsing via ua-parser-js 1.0.41 (pinned) - the de-facto standard library.
• isBot combines the library's own classification with a curated substring list (search crawlers, AI crawlers, SEO tools, social fetchers, HTTP clients, headless browsers, monitors). It is a signature list, so it is exact on the bots it knows and blind to ones it does not.
• Up to 1,000 strings per run.

FAQ

How do I parse User-Agent strings in bulk? Send {"userAgents": [...]} with up to 1,000 strings. Each returns one record with the same field shape, so the output drops straight into a dataframe or a database table.

Which bots does it detect? Search crawlers (Google, Bing, Yandex, Baidu, DuckDuckGo, Sogou), AI crawlers (GPTBot, ChatGPT, ClaudeBot and Anthropic, CCBot, PerplexityBot, Amazonbot, Bytespider), SEO tools (Ahrefs, Semrush, MJ12, DotBot, Screaming Frog), social preview fetchers (Facebook, Twitter, LinkedIn, Slack, Discord, WhatsApp, Telegram, Pinterest, Reddit), HTTP clients (curl, wget, python-requests, axios, okhttp, Go, Java, Guzzle, node-fetch), headless and scraping stacks (HeadlessChrome, PhantomJS, Scrapy), and uptime monitors (Pingdom and similar).

Can I use it to find AI training crawlers in my logs? Yes, this is a common use. Parse your log's UA column in batches, filter isBot: true, then match the specific names in userAgent for the AI crawlers you care about before deciding on robots.txt rules.

Does it handle Client Hints or Chrome's reduced User-Agent? It parses what the string contains - Chrome's frozen UA still yields browser, OS and engine. The fine-grained data lives in separate headers and is not recoverable from the UA string.

Why is device.type null for most of my traffic? Because most of it is desktop, and desktop UAs do not declare a device type. That is correct behaviour, not a miss.

What counts as an implausible string? Under 3 characters, or containing control characters. Those return {"ok": false, "error": "..."} and are never charged, so a mangled log column does not cost you.

Can an AI agent call this as a tool? Yes, through the Apify MCP server - an agent investigating traffic can classify a UA without you writing an integration.

Use from code or AI agents

curl -s "https://api.apify.com/v2/acts/EliAI~user-agent-parser/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST -H 'Content-Type: application/json' \
  -d '{"userAgents": ["Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/125.0.0.0 Safari/537.36"]}'

Agents: connect Apify MCP and call the EliAI/user-agent-parser tool.

• Capability: parse one or many User-Agent strings into browser / os / device / engine / cpu plus a bot verdict
• Required input: userAgent (string) or userAgents (array)
• Returns: one record per string; browser.name and isBot are the headline fields
• Bounded: 1,000 strings per run; failures isolate per string
• Side effects: none