Agent Verifier

Check a Web Bot Auth signature online, and see exactly what failed and what to change.

Input

🔒 Nothing is storedThe request is checked and discarded. An expired signature works too, checked as of the moment it was made.

Paste a curl command, a raw HTTP request, or the output of curl -v. Add the body after a blank line if the signature covers it.

Terminal

Console ready. Execute a command to see output...

About Agent Verifier

What Web Bot Auth is

When an automated client asks a website for a page, the site has to decide whether to serve it. Usually it decides on two things the client says about itself: the User-Agent string, which anyone can copy, and the address lists that operators publish, which many operators never publish. Impostors get served and real crawlers get blocked.

With Web Bot Auth the client proves who it is. It publishes a public key at a domain it controls and signs every request with the matching private key. The site checks the signature against the published key, and a valid signature shows that the request was signed with a key that domain publishes.

The standard is being written at the IETF, in a working group with editors from Cloudflare and Google and participants from Amazon and Mozilla. The signing mechanism underneath is RFC 9421, a finished standard. Cloudflare, AWS WAF, Akamai and DataDome check these signatures in production.

What the check tells you

A working setup needs three things right at the same time: a key, a published key directory, and a signature base that matches the request byte for byte. When one of them is wrong, a site usually answers with a bare refusal, and from the client side a malformed signature base and a site that has never heard of you look the same.

Paste the request your agent sent into the form above. The answer says what the signature proved, what the key directory publishes, and names the fault with the one change that fixes it, in the terms of the standard. The check is free and needs no account or key. To check the key directory on its own, before anything is signed, use the Directory Verifier.

The form and the API

The form checks a request you paste, so its answer covers the signature only. It cannot see the address the request came from, because the pasted copy reached this site from your browser. For the full answer, address included, the agent sends its request to the API itself, or calls the same check through the MCP server.

Endpoint
GET https://fp.packet.guru/api/v1/connection

No body, no parameters, no account, no key. Send it directly, not through a proxy: the answer describes the request as it arrives, so anything that re-sends it on your behalf changes what the answer is about.

Calling the check from your agent

A signed call, and the answer it gets back, abbreviated. Everything in the answer is read from the request itself.

curl https://fp.packet.guru/api/v1/connection \
  -H 'Signature-Agent: sig1="https://your-agent.example/.well-known/http-message-signatures-directory"' \
  -H 'Signature-Input: sig1=("@authority" "signature-agent";key="sig1");created=…;expires=…;keyid="…";tag="web-bot-auth"' \
  -H 'Signature: sig1=:…:'
{
  "success": true,
  "signals": {
    "agent": {
      "signature": { "present": true, "outcome": "unverified" },
      "webBotAuthDetail": {
        "reason": "key-not-in-directory",
        "fix": "No key with this keyid is in your directory. Make sure
                keyid matches either the key thumbprint or its kid."
      },
      "knownBot": "none"
    }
  },
  "ip": { "org": "…", "origin": "datacenter" }
}

Unsigned callers get an answer too

Web Bot Auth is a draft standard, and many automated clients do not sign. They identify themselves by the address ranges their operator publishes, or not at all. The answer therefore covers two separate things, and both come back whether the request was signed or not.

If you sign

The signature

RFC 9421 with the Web Bot Auth profile. The check fetches the key directory named in the request, finds the signing key in it, and reports what the directory proves about its own key set. An agent card is a file that says who you are and what you promise to send. Point at it with type=cimd, the parameter the registry draft defines for it, and the check reads it back to you and compares the User-Agent it promises with the one that arrived.

Everyone, always

The address

Whether it sits inside a crawler range its operator publishes, what kind of network it belongs to, and whether it appears on public abuse lists. The check takes the address that opened the connection, never one from a header.

Prompt: ask an agent to check this machine

Paste this into any agent that can make an HTTP request. Nothing has to be set up first, and it works whether or not the agent signs. An agent that does not sign still gets the part of the answer about the address it called from.

Find out how this machine looks to the websites it visits, using the free check at
https://fp.packet.guru/api/v1/connection

Make one GET request to that address from this machine, directly. Do not use a proxy
and do not route it through any service that re-sends the request on your behalf,
because the answer describes the request exactly as it arrives.

Then tell me:

1. Did the request carry a Web Bot Auth signature at all? If it did and it failed,
   quote the fault and the fix sentence from the answer.
2. What kind of network is this address on, and who operates it?
3. Is this address inside any crawler range its operator publishes?
4. If the request carried no signature, say so and stop there: the answer describes an
   anonymous caller and prescribes nothing. If it carried one, list in order what the
   answer says has to change.

Answer only from what the response says. Do not guess and do not fill gaps from memory.

Further reading

The standards behind this

  • RFC 9421 HTTP Message Signatures. The mechanism everything here is built on.
  • RFC 7638 JWK Thumbprint. How a key identifier is derived from the key itself.
  • RFC 9651 Structured Field Values. The grammar the Signature-Agent header follows.

Not an agent? Privacy & Trust Index answers the same question for a person in a browser.