Explainer
What is Web Bot Auth, and should your agent sign requests?
Web Bot Auth lets bots sign HTTP requests so sites can verify them. Where the IETF draft stands, who signs and verifies today, and when it's worth it.

Web Bot Auth lets bots and AI agents sign their HTTP requests, using RFC 9421 HTTP Message Signatures, so a site can check who sent them. A valid signature proves which operator holds the key, not that the site agreed to the visit, per the IETF draft.
My take, as of November 17, 2026: if your agent browses sites behind Cloudflare, Akamai or Vercel, sign now. It’s still an IETF draft rather than a finished standard, so trust your verifier’s docs over anyone’s blog post, including this one.
Short on time?
Short on time? Here's my take.
- Your agent browses Cloudflare-, Akamai- or Vercel-fronted sites
- Sign now and register with Cloudflare
- It's the documented way to be recognized. Send the header format your verifier documents, and re-read the draft on each revision.
- You already run on AWS AgentCore Browser or Browserbase
- Turn on their built-in signing
- AgentCore's signing is in Preview and off by default. Browserbase's is a beta you request.
- You scrape a few sites that already gave you access
- Skip it for now
- An API key or an agreed IP allowlist does the same job with less setup.
- You run a site on Cloudflare, Vercel or AWS WAF with CloudFront
- Use the built-in verified-bot rules
- Verification already exists, with no code. Your job is the allow, challenge or block policy.
- You run a site on your own stack
- Hold off on a custom verifier
- Unless agent traffic matters to revenue. Keep IP and reverse-DNS checks, which Google still documents as the fallback.
Prices verified . Sponsors cannot buy a verdict or a position.
Is Web Bot Auth a standard yet? #
Not yet. It’s an IETF Internet-Draft sitting on top of a real standard.
That standard is RFC 9421, HTTP Message Signatures, a Standards Track RFC since February 2024. It defines the Signature-Input and Signature fields and parameters such as created, expires, nonce, keyid and tag, but it leaves “a means of retrieving the key material” to each application that uses it. RFC 9421.
Web Bot Auth is that profile for bots. The IETF’s Web Bot Auth working group (webbotauth) is active in the Web and Internet Transport area, chaired by David Schinazi and Rifaat Shekh-Yusef. Working group charter.
The group has one working-group document: draft-ietf-webbotauth-httpsig-protocol-01, “HTTP Message Signatures for automated traffic”, dated October 29, 2026. Its header says it’s intended for the Standards Track; it’s written by Thibault Meunier of Cloudflare and Sandor Major of Google, and expires on May 2, 2027. Datatracker.
The older individual drafts many explainers still link, draft-meunier-web-bot-auth-architecture-05 and draft-meunier-http-message-signatures-directory-05, now show as “Replaced”. The documents page also lists 11 other related individual drafts, including a registry draft at -04 and a signed-agent-metadata draft from November 2, 2026. Working group documents.
The charter set April 30, 2026 for sending the signing specs to the IESG, the IETF’s approving body, and August 31, 2026 for an operational best-practice document. The group has missed its April 2026 target. Charter milestones.
So when Browserbase’s September 2026 explainer refers to “the IETF standard” while describing Web Bot Auth’s key rules, I read that as shorthand. The datatracker shows an Internet-Draft, and I trust the datatracker.
| Piece | Status | Dates |
|---|---|---|
| RFC 9421, HTTP Message Signatures | Standards Track RFC; leaves key distribution to profiles | February 2024 |
| IETF webbotauth working group | Active; charter -01 approved | Current |
| draft-ietf-webbotauth-httpsig-protocol | Working-group draft -01; Standards Track intended | October 29, 2026; expires May 2, 2027 |
| Meunier architecture and directory drafts (-05) | Shown as Replaced | Superseded |
| Milestone: signing specs to the IESG | Missed | Target was April 30, 2026 |
| Milestone: operational best-practice document | No IESG state shown | Target was August 31, 2026 |
Source: IETF datatracker (charter, documents, draft -01) and RFC Editor. All read 17 Nov 2026. Scroll sideways for more columns.

How does signing a request work? #
The agent adds three headers to each request and publishes its public keys where any site can fetch them. Signature-Input and Signature come from RFC 9421 and carry the signing parameters and the signature itself. Signature-Agent, defined by draft -01, tells the site where to find the key directory.
That directory lives at /.well-known/http-message-signatures-directory on the signer’s domain. It’s a JWK Set served over HTTPS with the media type application/http-message-signatures-directory+json, and it must return a 200. Verifiers must not follow redirects to reach it.
Each signature needs created and expires, and the draft recommends that expires be “no more than 24 hours after created”. The keyid is the base64url SHA-256 thumbprint of the key, and the tag must be web-bot-auth. Per draft -01, the signature has to cover @authority or @target-uri, plus the signature-agent header.
The body isn’t covered unless you add a Content-Digest header and sign that too. A bare signature says who sent the request and where it was going, not what was in it.
Which header format should you send? #
I’d send whatever your main verifier documents, and switch when it updates. At Cloudflare today that means a bare quoted URL, even though the draft now asks for a dictionary.
This is where the docs drift apart. Draft -01 makes Signature-Agent a Structured Fields dictionary of https URIs: signers MUST send the dictionary form, verifiers MAY still accept the older bare string, and the dictionary member must be signed. Draft -01.
Google already sends the dictionary form, g="https://agent.bot.goog". Cloudflare’s docs, last updated October 8, show a plain double-quoted URL, and OpenAI documents "https://chatgpt.com" the same way.
The draft lets verifiers accept both forms, but Cloudflare’s docs say it implements the format from an earlier directory draft (-03) and will fail a message that uses the dictionary form. So at Cloudflare today, only the bare quoted string works.
Where does Cloudflare differ from the draft? #
On key types, expiry, nonces, the header format, the key directory and covered components. Each gap will bite you if you build from the draft alone.
| Setting | Draft -01 says | Cloudflare’s docs say |
|---|---|---|
| Key types | Reject HMAC and known test keys | Ed25519 only; other key types are ignored |
| Expiry window | expires recommended at most 24 hours after created |
“A minute is often sufficient” |
tag |
Must be web-bot-auth |
web-bot-auth |
| Nonce | Not required; replay handling points to RFC 9421 §7.2.2 | Recommended, but “there is currently no nonce validation” |
Signature-Agent |
Dictionary form, required from signers | Double-quoted https string only; the dictionary form fails |
| Key directory | JWK Set at the well-known path; 200, no redirects | The directory response must itself be signed (tag http-message-signatures-directory) |
| Covered components | @authority or @target-uri, plus signature-agent |
@query-params and @status are unsupported |
Sources: draft -01 and Cloudflare’s Web Bot Auth docs, verified 2026-11-17.
The expiry gap is the big one. A 60-second window against the draft’s 86,400-second ceiling is a 1,440-fold difference, and at Cloudflare that short window is your main protection against a captured request being replayed.
Who signs and who checks today? #
OpenAI’s ChatGPT cloud browser and part of Google-Agent’s traffic arrive signed, AWS AgentCore Browser and Browserbase sign when you opt in, and Cloudflare, Vercel and AWS WAF document verification. That’s fewer parties than the hype suggests, and most signing is partial or opt-in. I built this table only from pages each party published, and I’ve marked where one company vouches for another.
| Role | Who | Status (verified 2026-11-17) | Where I read it |
|---|---|---|---|
| Signs | ChatGPT cloud browser (OpenAI) | Live; Signature-Agent: "https://chatgpt.com" |
OpenAI Agent Access |
| Signs | Google-Agent | Experimental; a subset of requests, as agent.bot.goog | |
| Signs | AWS AgentCore Browser | Preview; off by default | AWS docs |
| Signs | Browserbase | Beta; access by request | Browserbase docs |
| Verifies | Cloudflare | Documented; agents register through the Bot Submission Form | Cloudflare docs |
| Verifies | Vercel | Since August 12, 2025, alongside IP and reverse-DNS checks | Vercel changelog |
| Verifies | AWS WAF | Since November 21, 2025; only when protecting CloudFront | AWS What’s New |
| Verifies | Akamai, HUMAN | Per OpenAI’s pages; I didn’t open their own docs | OpenAI Agent Access |
| Verifies | DataDome, F5 | Listed by AWS as supported vendors; I didn’t open their own docs | AWS docs |
Google is candid about how partial its rollout is: “We don’t sign every request of a particular agent.” Google. So a missing signature on a Google-Agent request isn’t, by itself, a sign of a fake.
OpenAI says Akamai, Cloudflare, HUMAN and Vercel “verify ChatGPT request signatures automatically”, and its help article lists no IP ranges for the cloud browser. OpenAI Agent Access, OpenAI Help. The per-vendor Allow steps for merchants are in my ChatGPT Wallet guide.
AWS WAF adds Web Bot Auth at no cost beyond standard WAF charges, and its AI category rule respects it. Vercel’s changelog doesn’t say which plans get it. AWS, Vercel.
One stale-docs flag: AWS’s AgentCore page still links draft-meunier-web-bot-auth-architecture, which the datatracker now shows as replaced. AWS docs, IETF documents. Treat any guide that links it as older than the current draft.
What I couldn’t find anywhere is adoption data. No page I opened says how many sites actually check signatures.
What does a valid signature prove, and what doesn’t it? #
It proves that whoever controls a key published in that directory signed this request, inside the time window. The draft tells verifiers not to attribute a request to an operator until the directory URL and the key are tied together. Draft -01.
The working group’s charter draws the rest of the line. It puts end-user authentication, APIs and agent-to-agent traffic, non-HTTP protocols, non-cryptographic auth, a bot-intent vocabulary and reputation tracking out of scope. Charter.
So a valid signature doesn’t tell you:
- Who the person behind the agent is. End-user authentication is outside the charter.
- That the site will let you in. AWS warns “Not all websites will recognize or allow signed agent traffic”, and that owners “may block, monitor, or rate-limit agent traffic regardless of cryptographic signatures”. AWS docs.
- That the agent is logged in anywhere. Browserbase: “A valid signature doesn’t grant access or sign your agent into a user account”. Browserbase docs. Signing in is a separate choice; see how a browser agent should handle your logins.
- What the bot intends to do. Intent vocabulary and reputation are both out of scope.
- What was in the body, unless
Content-Digestwas signed. - That it isn’t a replay. Cloudflare says “there is currently no nonce validation”, so a short
expiresis the guard there. Cloudflare docs.
That last point is where the vendor material disagrees. Browserbase’s blog says verification checks that a nonce “hasn’t been reused”, while Cloudflare’s docs say it doesn’t validate nonces, and I trust the verifier’s own docs.
Identity is not permission. A signed crawler should still honour robots.txt, rate limits and a site’s terms, and my ethical scraping checklist covers how a bot should introduce itself.

How do you add it to your agent? #
If your browser layer signs for you, start there. On AWS AgentCore Browser, signing is in Preview and off by default; you turn it on with browserSigning enabled set to true. Browserbase offers it as a beta by access request.
Browserbase’s blog says it is part of Cloudflare’s Signed Agents programme. Browserbase blog. My cloud browser guide covers choosing between the two and the rest of the field.
If you sign yourself, this is the order I’d follow, pieced together from draft -01 and Cloudflare’s docs:
- Generate an Ed25519 key pair. Cloudflare ignores every other key type.
- Publish a key directory at
/.well-known/http-message-signatures-directoryas a JWK Set over HTTPS that returns 200 without redirecting. - Sign the directory response itself with the tag
http-message-signatures-directory. Cloudflare requires this. - Sign every request with
created, a shortexpires, the thumbprintkeyidand the tagweb-bot-auth, covering@authorityandsignature-agent. Leave out@query-paramsand@status. - Test at crawltest.com/cdn-cgi/web-bot-auth. A 200 means verified, a 401 means an unknown key or a failed check, and a 400 means a malformed request.
- Register in Cloudflare’s Bot Submission Form with the verification method “Request Signature”.
- Rotate keys by publishing the new key beside the old one, as the draft describes.
- Check every proxy in your path. OpenAI’s help article tells you to confirm that intermediate proxies preserve all three signature headers. OpenAI Help.
I’d treat a 200 at Cloudflare’s test URL as the bar before you register. The dashboard side of step 6 is in my ChatGPT Wallet guide, and what Cloudflare sites can now do to named agents is in my post on per-agent controls.
Never borrow another operator’s Signature-Agent value. Verifiers look keys up against the directory URL, so a copied header gets you nothing and misrepresents who you are.
How do you verify signatures on your own site? #
If you’re on Cloudflare, Vercel, AWS WAF in front of CloudFront or Akamai, you don’t write code. Verification is built in, and your job is policy: which verified agents to allow, challenge or block. Vercel, AWS, OpenAI on Akamai.
On Cloudflare, my AI crawler categories explainer shows where verified agents land and what each bucket does.
If you run your own stack, draft -01’s verifier rules are the checklist:
- Tie the key to the URL first. Look keys up by the pair (directory URL, key), and don’t attribute a request until they match.
- Fetch directories defensively. No redirects; cap response size, key count and timeout; block private IP ranges to avoid server-side request forgery.
- Reject weak keys. HMAC keys and known test keys fail.
- Return one of three outcomes: verified, invalid or unverified. A failed directory fetch never makes a request trusted.
- Cache keys per the directory’s Cache-Control headers, as Google advises. Google.
Keep your old checks running. Google tells sites to keep IP, reverse-DNS and user-agent checks as a fallback, since it signs only some requests. My AI crawler user agents guide walks through those checks.
And allow only after verifying. OpenAI’s wording: “To apply an allowlist exception for signed browser requests, first verify their signatures.” OpenAI Agent Access.
So should your agent sign? #
Yes, if it browses Cloudflare-, Akamai- or Vercel-fronted sites; skip it for now if it scrapes a few sites that already gave you access. Here’s my pick for each case, on the documents above.
- Your agent browses Cloudflare-, Akamai- or Vercel-fronted sites at any scale: sign now and register. It’s the documented way those verifiers recognize an agent, and OpenAI’s own agent already arrives signed. Send the bare-string header Cloudflare documents until it updates.
- You’re on AWS AgentCore Browser or Browserbase: turn on their built-in signing. It’s Preview on AWS and beta on Browserbase, so expect changes, but you skip running key infrastructure.
- You run a small scraper against a few sites that already gave you access: skip it for now. An API key or an agreed IP allowlist does the job, because those sites already know who you are.
- You run a site on Cloudflare, Vercel or AWS WAF with CloudFront: use the built-in verified-bot rules. No code, and AWS charges nothing extra beyond standard WAF.
- You run a site on your own stack: don’t build a verifier yet unless agent traffic matters to revenue. Keep IP and reverse-DNS checks, which Google still documents as the fallback.
If I were building an agent product, I’d publish a key directory and sign every request this quarter. The cost is one key and a few headers, and the biggest CDNs already check signatures.
I’d re-read the draft on each revision, because the header format has already changed once. And I’d never treat a valid signature as permission to ignore robots.txt or a site’s terms; my AI crawler user agents guide shows how signed bots fit beside the older tokens.
What I couldn't verify (as of November 17, 2026)
- Akamai, HUMAN, DataDome and F5, first-hand. I didn’t open their own pages; their support rests on OpenAI’s and AWS’s docs.
- How many sites verify signatures. No page I opened gives a number.
- OpenAI’s help article, directly. It returned 403, so I read it through a reader service.
FAQ #
Is Web Bot Auth an official standard? #
Not yet. It’s an IETF Internet-Draft, draft-ietf-webbotauth-httpsig-protocol-01, dated October 29, 2026 and intended for the Standards Track. It’s built on RFC 9421, which has been a standard since February 2024. Datatracker, RFC 9421.
What is the Signature-Agent header? #
It tells a site where the signer’s key directory lives. Draft -01 says signers must send it as a dictionary, like g=“https://agent.bot.goog”, while Cloudflare’s docs and OpenAI still show a bare quoted URL. The draft lets verifiers accept both, but Cloudflare’s docs say the dictionary form fails there today. Draft -01, Cloudflare docs.
Does a valid signature get my agent past bot protection? #
No guarantee. AWS says sites may block, monitor or rate-limit agent traffic regardless of cryptographic signatures, and Browserbase says a valid signature doesn’t grant access. The site’s policy decides. AWS docs, Browserbase docs.
Which bots sign requests today? #
OpenAI’s ChatGPT cloud browser signs as chatgpt.com, and Google signs a subset of Google-Agent requests as agent.bot.goog. AWS AgentCore Browser (Preview) and Browserbase (beta) sign when you opt in. OpenAI, Google, AWS, Browserbase.
Does Web Bot Auth stop replay attacks? #
Not on its own at Cloudflare. Cloudflare says it does not validate nonces, so a short expiry is the main guard; it suggests a minute is often enough. The draft doesn’t require a nonce. Cloudflare docs, draft -01.
Do I still need robots.txt rules? #
Yes. A signature tells a site who you are, not what you’re allowed to do. Keep honouring robots.txt and terms as a crawler, and keep your robots.txt rules as a site owner. Ethical scraping checklist, AI crawler user agents.
Sources
13 sources, accessed .
Official pricing, docs, changelogs and status pages 12
- IETF datatracker: Web Bot Auth working group charter and milestones
- IETF datatracker: Web Bot Auth working group documents
- IETF: draft-ietf-webbotauth-httpsig-protocol-01, HTTP Message Signatures for automated traffic (2026-10-29)
- RFC 9421: HTTP Message Signatures (February 2024)
- Cloudflare docs: Web Bot Auth (updated 2026-10-08)
- Google: Web Bot Auth for Google-Agent (updated 2026-10-13)
- OpenAI Help: ChatGPT cloud browser allowlisting (read via a reader service)
- OpenAI developers: Agent Access
- AWS docs: AgentCore Browser Web Bot Auth (Preview)
- AWS What's New: AWS WAF supports Web Bot Auth (2025-11-21)
- Vercel changelog: bot verification supports Web Bot Auth (2025-08-12)
- Browserbase docs: agent identity overview (beta)


