# [AI agent user agents: a field guide to request identification](https://rebilder.com/learn/ai-agent-user-agents)

> Real AI agent user agent strings (ChatGPT-User, GPTBot, claude-code, PerplexityBot), the exact headers each one sends, and how to detect them properly.

- **Updated:** 2026-09-10
- **Author:** Rebilder
- **Published:** 2026-08-05

This reference lists user-agent patterns and header examples used by Rebilder’s detector. Captured examples, detector markers and vendor-published strings have different provenance; the tables identify them. Use the current classifier documentation when integrating.

Request headers help classify traffic. Verify identity separately before granting access to private data or actions.

## How to read AI agent user agents

Group request patterns by their documented role, then inspect the response and verification state:

- **User-initiated fetchers** include `ChatGPT-User` and `Perplexity-User`. Their headers identify a request type; they do not establish a unique person or purchase intent.
- **Index and training crawlers** include `GPTBot`, `OAI-SearchBot` and `PerplexityBot`. Their request role differs from a user-initiated browsing fetch.
- **Terminal agents** are CLI coding agents that fetch pages during a working session and ask for markdown outright: `claude-code`, `opencode`.
- **Search crawlers** are `Googlebot` and `bingbot`. Recognized by the same detector, but classified as crawlers, not agents, and always served canonical HTML.

> **A user agent is a claim** A user-agent string is self-reported. Use it for classification; private information and actions require the appropriate authorization.

## OpenAI: ChatGPT-User, GPTBot, and OAI-SearchBot

The detector recognizes these OpenAI client patterns. Match the relevant token and interpret it alongside the other available signals:

| User-agent string | What it does | Verified? | How to detect it |
| --- | --- | --- | --- |
| `Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/1.0; +https://openai.com/bot` | Fetches a page live while a ChatGPT user is asking about it. User-initiated browsing, not crawling. | Sometimes: our `ChatGPT-User/2.0` captures carry Web Bot Auth signature headers. Parsed on every request, and cryptographically verifiable against a key registry you supply. | The classifier can use Signature-Agent for attribution. Successful cryptographic verification is a separate result. |
| `Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.2; +https://openai.com/gptbot` | OpenAI’s bulk crawler. Broad fetches with `Accept: */*`, not tied to a live question. | No, UA-only identification. | `GPTBot` UA token, capped at medium confidence. Format decisions only. |
| `Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot` | OpenAI’s search fetcher, classified to the `chatgpt` platform like GPTBot. | No, UA-only identification. | `OAI-SearchBot` UA token, medium confidence. |

Use the classified activity to understand which response paths receive requests and whether the site supplies useful information.

## Anthropic: the Claude user agent family

The Claude family member our corpus holds full captures for is `claude-code`, Anthropic’s terminal coding agent, and the most explicit requester in that corpus, because it does not make you guess: it sends an `Accept: text/markdown` media range alongside its CLI user agent. A captured request, verbatim:

Claude Code fetching a product page: captured headers

```http
GET /products/olive-oil-500ml HTTP/1.1
Host: store.example.com
User-Agent: claude-code/1.0.58 (external, cli)
Accept: text/markdown;q=1.0, text/html;q=0.8, text/plain;q=0.5, */*;q=0.1
Accept-Encoding: gzip, deflate, br
```

| User-agent string | What it does | Verified? | How to detect it |
| --- | --- | --- | --- |
| `claude-code/1.0.58 (external, cli)` | Claude Code fetching a page during a working session. | No signature in this example. The Accept header expresses a format preference, not verified identity. | Match the `Accept` header first (high confidence); the `claude-code` UA token then attributes the platform. |
| `claude-code/2.0.13 (external, cli)` | Same agent, next major version, captured against a shipping-policy page with `Accept: text/markdown, text/plain;q=0.8, */*;q=0.5`. | Same as above. | Same as above. Versions churn; match the token, never pin a version. |
| `ClaudeBot` · `Claude-User` · `claude-web` · `anthropic-ai` (UA markers) | Claude fetching pages for a user or for retrieval outside the CLI. | No, UA-only. | Substring match on any marker → `claude` platform, medium confidence. |

Rows marked UA markers describe detection patterns. Full-header examples are separate test fixtures; consult the classifier documentation for current coverage.

## Perplexity: PerplexityBot and Perplexity-User

The Perplexity user agent comes in two forms, and the split mirrors OpenAI’s: an index crawler that builds the corpus behind its answers, and a user-initiated fetcher that fires when a person asks something your page answers. Both classify as agent traffic on the `perplexity` platform:

| User-agent string | What it does | Verified? | How to detect it |
| --- | --- | --- | --- |
| `Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot)` | Index crawler: the corpus behind Perplexity’s answers. | No, UA-only. | `PerplexityBot` UA token, medium confidence. |
| `Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Perplexity-User/1.0; +https://perplexity.ai/perplexity-user)` | User-initiated fetch: a live question is behind it. | No, UA-only. | `Perplexity-User` UA token, medium confidence. |

Two practitioner details from the captures. First, both send fully browser-like `Accept: text/html,...` headers, so nothing but the UA separates them from a human visitor, which is why UA matching sits last in the detection order. Second, note the parenthesis placement: unlike `ChatGPT-User`, the `compatible; ...` clause sits **inside** the `(KHTML, like Gecko; ...)` parenthetical. Regexes built on the ChatGPT shape silently miss Perplexity. Match tokens, not shapes.

## OpenCode, Googlebot, and bingbot

These examples cover a terminal agent and the search or preview clients recognized by the detector.

| User-agent string | What it does | Verified? | How to detect it |
| --- | --- | --- | --- |
| `opencode/0.5.29` · `opencode/1.0.2 (linux; x64)` | OpenCode (SST), an open-source terminal coding agent. Sends `Accept: text/markdown` like Claude Code. | No signature; the `Accept` header carries the intent. | `Accept` header first; `opencode` UA token attributes the platform. |
| `Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)` | Google’s desktop search crawler. | Special-cased: always classified `crawler`, never `agent`. | `Googlebot` UA token → serve canonical HTML, no exceptions. |
| `Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.6422.175 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)` | Googlebot smartphone: a full Chrome-on-Android UA with the Googlebot clause at the end. | Same special case. | Match the `Googlebot` token **anywhere** in the string, not just as a prefix. |
| `Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)` (vendor-published) | Microsoft’s search crawler. Treat this as a Bing request classification, not a complete account of every Copilot retrieval path. | Same special case. | Substring match on `bingbot` → `crawler`; canonical HTML always. |
| `Mozilla/5.0 (compatible; adidxbot/2.0; +http://www.bing.com/bingbot.htm)` (vendor-published) | Bing Ads landing-page quality crawler. It audits ad destinations for policy compliance. | Same special case. | Serve the corresponding canonical page and its current offer information. |
| `Mozilla/5.0 (compatible; MicrosoftPreview/2.0; +https://aka.ms/MicrosoftPreview)` (vendor-published) | Link unfurling in Microsoft products: the preview card when someone pastes your URL into Teams or Outlook. | Same special case. | Classified as a preview client so preview traffic can be distinguished from search crawling. |

> **Distinguish search requests from Copilot referrals** A Copilot referral identifies an arriving visitor when that referrer is available. Search and preview requests are classified separately by their observed headers. The two measures describe different activity.

> **The crawler guardrail** Rebilder’s classifier gives recognized crawler tokens precedence and serves its canonical HTML path. This documents the current routing behavior; it does not guarantee search rankings.

## Headers beat user agents: Accept and Web Bot Auth

`Accept: text/markdown` expresses a response-format preference. Honor its q-values and use the classifier’s documented precedence for recognized crawlers. The header does not authenticate the requester.

The second header family is **Web Bot Auth**: three headers that let an agent platform cryptographically sign its requests. The following illustrative fixture shows the three fields:

Web Bot Auth header structure: illustrative test fixture

```http
GET /products/espresso-grinder HTTP/1.1
Host: store.example.com
User-Agent: Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/2.0; +https://openai.com/bot
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Signature-Agent: "https://chatgpt.com"
Signature-Input: sig1=("@authority" "signature-agent");created=1754265600;expires=1754266200;keyid="JrQLj5C_-uusgQwmSFvHYK2PxYlbcO9zRMoDHIQdVRo";tag="web-bot-auth"
Signature: sig1=:TWFrZSBhZ2VudHMgZmlyc3QtY2xhc3MgY2l0aXplbnMgb2YgdGhlIHdlYi4=:
```

- **`Signature-Agent`** names the claimed signer. Verify the signature with a trusted key before treating the identity as authenticated.
- **`Signature-Input`** lists which request components are covered, plus metadata: `created`, `expires`, a `keyid`, and the `tag="web-bot-auth"` label.
- **`Signature`** carries the signature bytes themselves. A bare `Signature` + `Signature-Input` pair without `Signature-Agent` still means agent: unknown platform, medium confidence.

> **Configure signature verification** Configure trusted keys for signature verification as described in the integration reference. A parsed signature header and a successfully verified signature are distinct states. Use the verified result and the action’s authorization when granting access.

## How to detect AI agents properly

The current classifier uses this precedence. Review [Classification](/docs/classification) for implementation details and the meaning of confidence labels:

1. **Known crawler UA? Classify `crawler` and stop.** The guardrail runs before everything: a `Googlebot` or `bingbot` token always classifies as `crawler` and gets canonical HTML, even when every other signal fires.
2. **Then check `Accept: text/markdown`.** A positive q-value expresses preference for that format; it is not proof of identity.
3. **Then Web Bot Auth headers.** Parse the claimed platform and signature fields; inspect the separate verification result for authentication.
4. **Then protocol routes.** Requests to `/.well-known/ucp`, `/.well-known/acp`, `/mcp`, or `/acp/*` are protocol probes, worth logging today, with the supported endpoints configured through the gateway.
5. **UA heuristics last.** Match supported tokens for classification. Access to private terms or operations uses separate authorization.
6. **Default: human.** A browserish `Accept: text/html` or `Mozilla/` UA → high confidence; empty or garbage headers → low.

You can implement this order yourself (headers first, UA last, crawlers pinned to canonical HTML) or install it: [Rebilder’s gateway](/docs/quickstart) ships this exact classifier free, with adapters for Next.js, Shopify, Express, Fastify, and Cloudflare Workers, and answers `Accept: text/markdown` with markdown rendered from your own product data. The full ordering is documented in [Classification](/docs/classification).

## A living corpus, not a static list

The detector’s fixtures provide repeatable tests for supported patterns. Captures and vendor-published examples can be added as clients evolve. Check the current classifier version when comparing this reference with production traffic.

Connect reporting to see classified requests in the Console. Its preview compares [requester responses](/help/agent-traffic/which-agents-detected) so you can inspect the information returned by the site.

## What user agent does ChatGPT use?

Three, for three jobs. `ChatGPT-User` fetches pages live while a user is asking (`Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/1.0; +https://openai.com/bot`). `GPTBot` is OpenAI’s bulk crawler, and `OAI-SearchBot` is its search fetcher. All three classify to the same `chatgpt` platform; newer `ChatGPT-User` fetches also carry Web Bot Auth signature headers.

## What is the GPTBot user agent?

The full string in our captures is `Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.2; +https://openai.com/gptbot`. It is OpenAI’s bulk crawler: broad fetches with `Accept: */*`, no live user attached, identifiable only by the UA token.

## What user agent does Claude use?

The family member our fixture corpus holds full captures for is Claude Code, Anthropic’s terminal agent: `claude-code/1.0.58 (external, cli)` and later versions, always alongside an explicit `Accept: text/markdown` header. The wider Claude family is matched by the UA markers `ClaudeBot`, `Claude-User`, `claude-web`, and `anthropic-ai`.

## Can AI agent user agents be spoofed?

Yes. A user-agent string is self-reported, as is an unsigned format header. Use signature verification and the appropriate authorization for private operations.

## Should I block AI agents like GPTBot from my store?

Choose which crawlers and clients the business intends to serve, configure the corresponding access rules, and review actual request and referral activity.

## How do I see which AI agents are visiting my website?

Use server reporting for direct requests and browser reporting for observable browser activity. Rebilder classifies connected request events; inspect the evidence and coverage rather than assuming every agent is identifiable.

## Related

- [AI search optimization: the definitive guide](https://rebilder.com/learn/ai-search-optimization)
- [What is agentic commerce?](https://rebilder.com/learn/what-is-agentic-commerce)
- [How agent detection works](https://rebilder.com/docs/classification)
- [Which agents Rebilder detects](https://rebilder.com/help/agent-traffic/which-agents-detected)
- [Gateway quickstart](https://rebilder.com/docs/quickstart)
- [Free llms.txt generator](https://rebilder.com/tools/llms-txt-generator)