# UserStack User-Agent Lookup MCP for AI Agents AI Agent Connect

> UserStack User-Agent Lookup provides your AI agent with high-fidelity device and browser intelligence. It parses messy User-Agent strings into clean data like OS, browser version, and hardware brand. It also identifies search engine crawlers and bots with high accuracy for web traffic analysis and security auditing.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_C73gpXQc76w4GftWbngd8wPaY3sHJgU9EsWqwUY7/ai-agent-connect
- **Tags:** user-agent, device-detection, browser-parsing, web-analytics, bot-detection

## Description

Imagine you're looking at a pile of raw web logs. They're full of cryptic strings that are nearly impossible for a human to read quickly. This Connector changes that by letting your AI agent act as a technical analyst. Instead of guessing what a visitor is using, you can ask your agent to break down the data. It'll tell you if someone is on an iPhone in London or a Windows desktop in New York. It even spots the difference between a real person and a crawler trying to scrape your site. By using this through the Vinkius catalog, you're giving your agent a specialized lens to see the hardware and software behind every request. It turns raw data into actionable insights for debugging, security, or marketing without you having to manually map every browser version ever released.

## Tools

### detect_user_agent
Identifies the device, browser, and OS from a provided User-Agent string. It turns raw logs into readable data.

## Prompt Examples

**Prompt:** 
```
Check this UA: Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Mobile/15E148 Safari/604.1
```

**Response:** 
```
I've parsed that string. It's an **Apple iPhone** running **iOS 14.6**. The user is using the **Safari mobile** browser.

**Summary Table:**
| Attribute | Value |
| :--- | :--- |
| Device | iPhone |
| OS | iOS 14.6 |
| Browser | Safari |
| Type | Mobile |
```

**Prompt:** 
```
Is this a bot? 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)'
```

**Response:** 
```
Yes, that's a **verified search engine crawler**. It's identified as **Googlebot version 2.1**.

*   **Status:** Bot
*   **Source:** Google
*   **Type:** Search Engine Crawler
```

**Prompt:** 
```
Identify the device for: 'Mozilla/5.0 (Linux; Android 11; SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124'
```

**Response:** 
```
This request comes from a **Samsung Galaxy S21** running **Android 11**. The user is browsing with **Google Chrome**.
```

## Capabilities

### Parse UA strings into structured data
It turns raw, messy browser strings into clean labels for the OS, browser, and device type.

### Identify search engine crawlers and bots
The agent can distinguish between real human visitors and automated scripts like Googlebot.

### Retrieve specific mobile device brands and models
Get exact hardware details like phone models for better mobile experience targeting.

### Verify OS and browser versions for web clients
Check the specific software version a user is running to debug compatibility issues.

### Filter out non-human traffic from web logs
Easily separate bot activity from real user behavior in your traffic data.

## Use Cases

### Debugging a CSS bug
A developer asks the agent to check if a specific UA is using a mobile Safari browser to see why a layout is breaking.

### Security audit
A security analyst asks the agent to identify all bots in a list of 500 recent requests to find a scraper.

### Marketing segmentation
A marketer wants to know the OS distribution of users visiting a specific landing page to tailor their ads.

### Traffic filtering
An ops lead asks the agent to flag any requests that aren't from human users to clean up their analytics dashboard.

## Benefits

- Stop guessing what browsers your users have by using detect_user_agent to get exact versions.
- Spot scrapers faster with high-precision bot detection built into the UA parsing.
- Get specific hardware details like phone models for better mobile experience targeting.
- Clean up your analytics by filtering out bot traffic automatically.
- Save hours of manual work by letting your agent handle complex string decoding.

## How It Works

The bottom line is your agent gets instant, accurate hardware and software details from any web request.

1. Subscribe to the UserStack User-Agent Lookup MCP on Vinkius.
2. Add your UserStack Access Key to your environment.
3. Ask your agent to identify devices or bots from any UA string.

## Frequently Asked Questions

**What does UserStack User-Agent Lookup do?**
It takes messy browser strings and turns them into clear info about what device, browser, and OS a visitor is using.

**Can it tell the difference between a bot and a human?**
Yes, it identifies search engine crawlers and bots with high accuracy so you can filter them out of your data.

**How does it help with web development?**
It helps you debug browser-specific bugs by quickly identifying the exact software version a client is running.

**Can I use it to see what phones my visitors have?**
Yes, it can identify specific mobile brands and models, which helps you optimize for the most popular devices.

**Does it work for all browsers?**
It parses a wide range of User-Agent strings, covering all major desktop and mobile browsers.

**How do I get my access key?**
You can get your UserStack Access Key directly from their website to connect this Connector to your agent.

**Can I identify if a user is on an iPhone?**
Yes! Use the `detect_user_agent` tool. The response will include the device brand ('Apple') and the specific model or type if available in the UA string.

**Does this server detect search engine bots?**
Yes. The underlying API identifies known crawlers like Googlebot or Bingbot. The agent will explicitly state if the detected agent is a crawler.

**Can I parse multiple User-Agents at once?**
Currently, the `detect_user_agent` tool processes one string per call. You can ask your AI agent to perform sequential checks for a list of strings.