What is ChatGPT agent?
To detect ChatGPT agent, verify its Web Bot Auth signature: OpenAI's cloud browser sends a standard Chrome User-Agent header, but it signs each request with a key that OpenAI publishes on chatgpt.com. ChatGPT agent is the cloud-hosted browser that ChatGPT uses to read pages, click buttons, and fill in forms for a person. Arcjet verifies the signature and reports the bot CHATGPT_AGENT with SIGNATURE evidence and the operator chatgpt.com.
OpenAI introduced ChatGPT agent on July 17, 2025, as an agent that works on its own virtual computer with a visual browser. As of November 2026, OpenAI's documentation calls the same capability the cloud browser in ChatGPT Work. OpenAI's cloud browser access guide describes a browser that can "read pages, click buttons, and complete tasks" such as finding products, comparing options, or filling out forms for a user. Arcjet keeps the bot ID CHATGPT_AGENT for this signing identity, and this article uses the name ChatGPT agent for it.
ChatGPT agent is the signed-browser case. It runs a real browser on OpenAI's infrastructure, so its headers look like Chrome, and nothing in the request names ChatGPT except the signature. Meta's Muse is the delegated case, and it's covered in How to detect Meta's Muse AI agent.
For more information about the other ways to identify agents, see How to identify AI agents and bots.
How do ChatGPT agent, ChatGPT-User, and GPTBot differ?
ChatGPT agent, ChatGPT-User, and GPTBot are three different OpenAI clients with three different jobs. ChatGPT agent is a cloud browser that acts for a person, ChatGPT-User fetches a single page when a person asks ChatGPT about it, and GPTBot crawls pages to train OpenAI's models. Each one is verified a different way, and each needs its own policy.
OpenAI documents its crawlers and fetchers on its bots page and its cloud browser on the cloud browser access guide. The following table combines both, as of November 2026:
| Client | What OpenAI says it does |
| How to verify it | Arcjet bot ID and kind |
|---|---|---|---|---|
| ChatGPT agent (cloud browser) | Reads pages, clicks buttons, and completes tasks for a user, from a browser on a separate computer in the cloud. | None documented. The browser sends a standard Chrome
| Web Bot Auth signature, with |
|
| ChatGPT-User | "When users ask ChatGPT or a CustomGPT a question, it may visit a web page with a ChatGPT-User agent." | compatible; ChatGPT-User/1.0; +https://openai.com/bot | IP ranges at |
|
| GPTBot | Used "to make our generative AI foundation models more useful and safe." | compatible; GPTBot/1.4; +https://openai.com/gptbot | IP ranges at |
|
| OAI-SearchBot | Used "to surface websites in search results in ChatGPT's search features." | | IP ranges at |
|
OpenAI notes that the version numbers in the GPTBot and OAI-SearchBot strings can change, so match the token, not the full string. OpenAI also documents OAI-AdsBot, which "only visits pages submitted as ads", with ranges at https://openai.com/adsbot.json.
The robots.txt rules differ too. According to OpenAI's bots page, disallowing GPTBot "indicates a site's content should not be used in training generative AI foundation models", and sites opted out of OAI-SearchBot "will not be shown in ChatGPT search answers." For ChatGPT-User, OpenAI says that "because these actions are initiated by a user, robots.txt rules may not apply." The cloud browser access guide says that allowing cloud browser traffic doesn't affect OpenAI's crawlers, which have separate controls. It doesn't mention robots.txt for the cloud browser.
The table is why one rule for "OpenAI" doesn't work. Blocking CATEGORY:AI stops GPTBot, and it also stops ChatGPT-User and ChatGPT agent, because every AI agent is in that category as well. For more information about separating the two groups, see How to block AI crawlers but allow AI agents.
How does ChatGPT agent sign requests?
ChatGPT agent signs requests with Web Bot Auth, which builds on RFC 9421 HTTP Message Signatures. Each signed request carries Signature, Signature-Input, and Signature-Agent headers, and OpenAI publishes the public keys at https://chatgpt.com/.well-known/http-message-signatures-directory. A valid signature proves that the request came from whoever controls chatgpt.com.
OpenAI's cloud browser access guide tells site owners to "confirm the Signature-Agent header exactly matches "https://chatgpt.com", including the quotation marks." That's the earlier, quoted-string form of the header. The Web Bot Auth draft has since moved to a dictionary form keyed by the signature label, and verifiers differ in which forms they accept. Arcjet accepts both. For more information about the two forms, see Why are there two forms of Signature-Agent?.
Three details of OpenAI's setup matter to a verifier:
- The directory forbids caching. On November 16, 2026,
chatgpt.comserved its directory withCache-Control: no-store, no-transform. A verifier that honors that header reads the directory again for every signed request. Arcjet does this with a 150 millisecond limit and falls back to the other bot signals if the directory is slow. - The signature covers the path. A ChatGPT agent request that SeatGeek published in its write-up covers
@authority,@method,@path, andsignature-agent, with a one-hour expiry. Your server needs the original request path to rebuild the signature base. - Proxies must keep the headers. OpenAI's guide covers the
Signature,Signature-Input, andSignature-Agentheaders. A proxy that strips any of them, or rewrites theHostheader, breaks verification.
OpenAI's guide says that Akamai, Cloudflare, HUMAN, and Vercel verify ChatGPT's signatures automatically, and that other providers need manual verification. OpenAI's help center article ChatGPT Work's Cloud browser allowlisting gives the same Signature-Agent check and key directory URL. For more information about manual verification, see How do you verify Web Bot Auth signatures?.
What does a ChatGPT agent signature prove?
A ChatGPT agent signature proves that OpenAI's cloud browser sent the request. It doesn't identify the ChatGPT user, prove that the user approved a specific action, or make the request single use. Anyone who copies the signed headers can replay them until the signature expires, within the limits of the components that it covers.
ChatGPT agent doesn't present a Personal Agent Protocol session, as of November 2026. OpenAI is one of the personal-agent design partners on the protocol's path to 1.0 page, but it hasn't published a Poppy client_id. A ChatGPT agent identity therefore has delegated set to false.
How do you detect ChatGPT agent with Arcjet?
To detect ChatGPT agent with Arcjet, name CHATGPT_AGENT or CATEGORY:AI_AGENT in a detectBot rule and read the bot identity in your route handler. Arcjet Cloud fetches OpenAI's key directory, verifies the signature, and reports CHATGPT_AGENT with kind AI_AGENT, evidence SIGNATURE, and operator chatgpt.com. ChatGPT-User has the bot ID OPENAI_CRAWLER_USER and IP evidence when it comes from OpenAI's published ranges.
CHATGPT_AGENT comes from the open source well-known-bots catalog, which records OpenAI's directory URL. Arcjet fetches only directories that the catalog or one of your rules names, so a request can't point Arcjet at a URL of its choosing.
The examples in the following sections allow ChatGPT agent and ChatGPT-User on product pages, and deny every bot, ChatGPT agent included, on a signup form that's meant for people. They use frameworks that pass the original request path to Arcjet, which a signature that covers @path needs. The Next.js App Router doesn't supply it. For the list of adapters, see Which frameworks preserve the signed path?.
Detect ChatGPT agent in JavaScript
The following Express app uses two Arcjet clients, one for each kind of route:
import arcjet, { detectBot } from "@arcjet/node";import { isAiAgent, isSpoofedBot } from "@arcjet/inspect";import express from "express";
// Product pages: search engines, ChatGPT agent, and ChatGPT-Userconst pages = arcjet({ key: process.env.ARCJET_KEY!, rules: [ detectBot({ mode: "LIVE", allow: ["CATEGORY:SEARCH_ENGINE", "CHATGPT_AGENT", "OPENAI_CRAWLER_USER"], }), ],});
// Signup form: people onlyconst forms = arcjet({ key: process.env.ARCJET_KEY!, rules: [detectBot({ mode: "LIVE", allow: [] })],});
const app = express();
app.get("/products/:id", async (req, res) => { const decision = await pages.protect(req); if (decision.isDenied() || decision.results.some(isSpoofedBot)) { res.status(403).json({ error: "Forbidden" }); return; }
for (const result of decision.results) { if (isAiAgent(result) && result.reason.isBot()) { const identity = result.reason.identity; // For example: CHATGPT_AGENT SIGNATURE chatgpt.com console.log(identity?.botId, identity?.evidence, identity?.operator); } }
res.json({ id: req.params.id });});
app.post("/signup", express.json(), async (req, res) => { const decision = await forms.protect(req); if (decision.isDenied()) { res.status(403).json({ error: "This form is for people. Agents can use the API.", api: "https://api.example.com/docs", }); return; }
res.json({ status: "accepted" });});
app.listen(3000);Detect ChatGPT agent in Python
The following FastAPI app does the same with is_ai_agent and reason_v2:
import os
from arcjet import BotCategory, Mode, arcjet, detect_bot, is_ai_agent, is_spoofed_botfrom fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponse
# Product pages: search engines, ChatGPT agent, and ChatGPT-Userpages = arcjet( key=os.environ["ARCJET_KEY"], rules=[ detect_bot( mode=Mode.LIVE, allow=[ BotCategory.SEARCH_ENGINE, "CHATGPT_AGENT", "OPENAI_CRAWLER_USER", ], ), ],)
# Signup form: people onlyforms = arcjet( key=os.environ["ARCJET_KEY"], rules=[detect_bot(mode=Mode.LIVE, allow=[])],)
app = FastAPI()
@app.get("/products/{product_id}")async def product(request: Request, product_id: str): decision = await pages.protect(request) if decision.is_denied() or any( is_spoofed_bot(r) for r in decision.results ): return JSONResponse({"error": "Forbidden"}, status_code=403)
for result in decision.results: reason = result.reason_v2 if is_ai_agent(result) and reason.type == "BOT" and reason.identity: # For example: CHATGPT_AGENT SIGNATURE chatgpt.com identity = reason.identity print(identity.bot_id, identity.evidence, identity.operator)
return {"id": product_id}
@app.post("/signup")async def signup(request: Request): decision = await forms.protect(request) if decision.is_denied(): return JSONResponse( { "error": "This form is for people. Agents can use the API.", "api": "https://api.example.com/docs", }, status_code=403, )
return {"status": "accepted"}Detect ChatGPT agent in Go
The following net/http server reads the identity from result.Reason.Bot.Identity:
package main
import ( "log" "net/http" "os"
"github.com/arcjet/arcjet-go")
func main() { // Product pages: search engines, ChatGPT agent, and ChatGPT-User pages, err := arcjet.NewClient(arcjet.Config{ Key: os.Getenv("ARCJET_KEY"), Rules: []arcjet.Rule{ arcjet.DetectBot(arcjet.BotOptions{ Mode: arcjet.ModeLive, Allow: []string{ arcjet.BotCategorySearchEngine, "CHATGPT_AGENT", "OPENAI_CRAWLER_USER", }, }), }, }) if err != nil { log.Fatal(err) }
// Signup form: people only forms, err := arcjet.NewClient(arcjet.Config{ Key: os.Getenv("ARCJET_KEY"), Rules: []arcjet.Rule{ arcjet.DetectBot(arcjet.BotOptions{ Mode: arcjet.ModeLive, Allow: []string{}, }), }, }) if err != nil { log.Fatal(err) }
http.HandleFunc("GET /products/{id}", func(w http.ResponseWriter, r *http.Request) { decision, err := pages.Protect(r.Context(), r) if err != nil || decision.IsDenied() || decision.IsSpoofedBot() { http.Error(w, "Forbidden", http.StatusForbidden) return }
if decision.IsAIAgent() { for _, result := range decision.Results { if bot := result.Reason.Bot; bot != nil && bot.Identity != nil { id := bot.Identity // For example: CHATGPT_AGENT SIGNATURE chatgpt.com log.Println(id.BotID, id.Evidence, id.Operator) } } }
w.Write([]byte("ok")) })
http.HandleFunc("POST /signup", func(w http.ResponseWriter, r *http.Request) { decision, err := forms.Protect(r.Context(), r) if err != nil || decision.IsDenied() { http.Error(w, "This form is for people. Agents can use the API.", http.StatusForbidden) return }
w.Write([]byte("accepted")) })
log.Fatal(http.ListenAndServe(":3000", nil))}Why isn't the first signed request verified?
A signed request can arrive before Arcjet has read OpenAI's directory. Arcjet then decides that request with its other bot signals instead of waiting, and verifies later requests. Because OpenAI's directory forbids caching, Arcjet reads it during each signed request after it learns that, and shares the result only among the signatures on that request.
Don't make a signature the only way that a request to an allowed route succeeds. On the product route in the preceding examples, an unverified ChatGPT agent request looks like Chrome and passes as a browser. On the signup route, the rule denies a verified ChatGPT agent request by name, and Advanced Signals can catch an unverified one by detecting browser automation.
What policy fits ChatGPT agent?
A reasonable policy allows ChatGPT agent on public content, rate limits it, and keeps account creation, sign-in, and checkout under your own authorization checks. The signature tells you that OpenAI's cloud browser sent the request. It doesn't tell you which person sent the agent or whether they approved the action.
The following defaults work for most sites:
- Allow it on public pages. Product pages, pricing, docs, and support articles are pages that the person would read themselves.
- Give it its own rate limit. Key a limit by bot ID, so that ChatGPT agent shares one budget across every person who uses it. The AI agents documentation shows this with the
botIdcharacteristic. - Decide on forms per route. A newsletter or signup form that's meant for people can deny every bot, ChatGPT agent included, and point agents at your API.
- Authorize purchases in your own code. OpenAI's guide says that human review is required before consequential actions such as checkout. Keep your own fraud checks and limits regardless.
- Check evidence where it matters.
isAiAgentdoesn't check evidence. On a route where only a verified agent may proceed, compareevidencewithSIGNATURE. - Start in
DRY_RUN. Measure how often ChatGPT agent reaches each route before you enforce a rule.
Some agents can't be identified from the server at all, because they run in the person's own browser. For more information about that case, see How to detect AI browser agents. For more information about the evidence levels in the identity, see AI agent evidence levels.
Frequently asked questions
Does ChatGPT agent identify itself in the User-Agent header?
No. OpenAI documents no User-Agent token for its cloud browser, which sends a standard Chrome User-Agent. ChatGPT agent identifies itself with a Web Bot Auth signature instead, with Signature-Agent set to "https://chatgpt.com".
What's the difference between ChatGPT agent and ChatGPT-User?
ChatGPT agent is a cloud browser that clicks, types, and fills in forms for a person, and it's verified by its signature. ChatGPT-User fetches a page when a person asks ChatGPT about it, sends the ChatGPT-User token, and is verified by OpenAI's published IP ranges. Arcjet reports them as CHATGPT_AGENT and OPENAI_CRAWLER_USER.
Can I block ChatGPT agent but allow ChatGPT search?
Yes. ChatGPT search uses OAI-SearchBot, which Arcjet reports as OPENAI_CRAWLER_SEARCH in CATEGORY:SEARCH_ENGINE. Add CHATGPT_AGENT to a deny list, or leave it out of an allow list that includes CATEGORY:SEARCH_ENGINE.
Does blocking GPTBot block ChatGPT agent?
Not if you block GPTBot by name. GPTBot is OpenAI's training crawler, with its own User-Agent token and IP ranges. A rule that denies all of CATEGORY:AI blocks both, because every AI agent is also in that category.
Does ChatGPT agent support the Personal Agent Protocol?
Not as of November 2026. OpenAI is a personal-agent design partner of the Personal Agent Protocol, but it hasn't published a Poppy client_id. A ChatGPT agent identity has SIGNATURE evidence from Web Bot Auth and delegated set to false.
Why does ChatGPT agent look like Chrome in my logs?
ChatGPT agent runs a real Chromium-based browser in the cloud, so its headers match Chrome. Only the Signature, Signature-Input, and Signature-Agent headers show that OpenAI sent the request, so log or verify those headers to tell it apart from a person.
Is ChatGPT agent the same as the cloud browser in ChatGPT Work?
Both names refer to the browser that ChatGPT runs in the cloud to act for a person. OpenAI introduced it as ChatGPT agent in July 2025, and as of November 2026 its documentation calls it the cloud browser in ChatGPT Work. It signs with the same chatgpt.com key directory, which Arcjet reports as CHATGPT_AGENT.
Application security in your code
Protect your application with Arcjet
Verify ChatGPT agent by its chatgpt.com signature in your route handler, and decide per route what it may do.