MCP server

The same self-check, reachable as a tool your agent can find on its own.

Someone has to read a page to find the HTTP API. An agent finds this door by itself: it lists the tools, sees what this one does, and calls it. Same engine, same answer.

Endpoint
https://fp.packet.guru/api/v1/mcp

Streamable HTTP, POST only. No account, no key, no registration.

Adding it to a client

Most clients ask only for the address above. Paste it and you are done. Clients that keep servers in a config file want something like this. Field names vary between clients, so check yours if it disagrees.

{
  "mcpServers": {
    "agent-verifier": {
      "type": "http",
      "url": "https://fp.packet.guru/api/v1/mcp"
    }
  }
}

What it exposes

self_check_web_bot_auth

Reports how the request carrying this call looks from the outside: whether its Web Bot Auth (RFC 9421) signature verified, what the key directory it named publishes, the exact fault if there is one and the sentence saying what to change, plus plain facts about the address it arrived from. Sign the call the way you sign requests to anyone else. Free, anonymous, no account. Takes no arguments: an unsigned call still gets an answer about its address.

Read-only, and it takes no arguments. The answer describes the request that carried the call, so there is nothing you could pass that would change it.

Two things worth knowing before the first call

  • Put your signature in the headers of the request, not in the arguments. The check reads the connection your client opened, so the Web Bot Auth headers have to be on that POST. The tool takes no arguments at all. Nothing you could type would change the answer, because the answer is about the request itself. An unsigned call still gets an answer, about its address.
  • Do not route it through a proxy. The answer describes the request exactly as it arrives, so anything that re-sends it on your behalf changes what the answer is about.

The raw call

For anyone implementing the transport by hand rather than using a client. The method and the tool name are mirrored into headers as well as the body, and a server that reads the body has to reject any request where the two disagree, so send both. The exact version string a client sends is whatever revision it speaks. The one below is what this server answers on.

POST /api/v1/mcp HTTP/1.1
Host: fp.packet.guru
Content-Type: application/json
Accept: application/json, text/event-stream
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: self_check_web_bot_auth

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "self_check_web_bot_auth",
    "arguments": {},
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientCapabilities": {}
    }
  }
}

There are no sessions and no GET stream here, so GET and DELETE answer 405. The result carries the verdict twice: once as text, once as structuredContent. They are the same object.

Prompt: ask an agent to run the check

Paste this into an agent that already has the server above connected. It calls the one tool and reports back. It only reads, so it changes nothing on your side.

Call the self_check_web_bot_auth tool on the agent-verifier server, then tell me:

1. Did my Web Bot Auth signature verify? If not, quote the fault and the fix sentence from the answer.
2. What does my key directory look like from outside, and did it prove it published the key that was used?
3. What kind of network does my address belong to, and is it inside any published crawler range?
4. List, in order, exactly what I should change. If nothing, say so plainly.

Do not guess at anything the answer does not state.

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.

For machines

  • API catalog Every API here, each with its description and its documentation. Standard address, RFC 9727.
  • openapi.json The response contract, machine-readable. The same source the reference page is built from.
  • MCP server card What an MCP registry reads about this server: address, transport, and the tool it exposes.
  • packet.guru key directory The public keys this site signs its own outbound requests with. A working example of the file you publish.
  • packet.guru agent card What the fetcher on this site promises about itself, including the exact User-Agent it sends.

Read next

Implementation guide Key, directory, signature, check. Step by step, with the usual mistakes.