# Remote MCP server for ChatGPT and Codex

signafAIde runs a public MCP server that an AI assistant can use without an account:

```text
https://api.signafaide.co.uk/mcp
```

It has five tools. All of them are read-only: they create nothing, change nothing and send nothing. There is no sign-in and no API key.

To set up recording inside a project, use the local MCP server instead: [Coding agents](/docs/coding-agents).

## Add it

**ChatGPT.** Open the plugins page, choose to add a custom MCP server, enter the address above and choose no authentication.

**Codex.** Add it from the command line:

```bash
codex mcp add signafaide --url https://api.signafaide.co.uk/mcp
```

or in `~/.codex/config.toml`:

```toml
[mcp_servers.signafaide]
url = "https://api.signafaide.co.uk/mcp"
```

**Any other MCP client.** Choose the Streamable HTTP transport and give the same address. The server answers every request with one JSON object and keeps no session.

## The tools

| tool | use it when | it returns |
|---|---|---|
| `signafaide_quickstart` | you are adding or changing a tool that pays, deletes, sends messages, runs commands, pushes code, or edits secrets or config, or want to record an agent's tool calls, in Python, TypeScript or JavaScript | the install command, the code for your framework, how to record tools you did not wrap, and the verify command |
| `signafaide_explain_error` | you have a signafAIde error code, such as `chain_conflict` or `invalid_key` | what the code means, how to fix it, and the address of its entry in the [error reference](/docs/errors) |
| `signafaide_check_auditor_link` | an organisation shared an auditor link with you | the organisation and project names, the environment, agents and period the link covers, when it expires, the number of records and agents, the public timestamp status, each of the 12 checks with its result, tool coverage notes, and the command for checking the records yourself |
| `signafaide_verify_pack` | you have a [verification pack](/docs/packs) to check | one line for each of the 12 checks, naming any record that fails, tool coverage notes, and a last line that starts with PASS or FAIL |
| `signafaide_service_keys` | you want the service's public signing keys | every key with its id and the dates it was valid, the address where the same list is published, and the verify command that uses it |

Each check has one of four results: pass, pending, not checked or fail. Pending and not checked are never counted as passed. What each check means: [Verify](/docs/verify).

A passing result is evidence that the records exist, are complete and were not altered. It is not a certification of the agent, the organisation or compliance with any law or standard.

`signafaide_explain_error` also explains the tool-call check codes `blocked`, `no_ruling`, `rules_unavailable` and `withheld`. The remote server does not read rulings: a ruling is read where the records are, with the local MCP server's `signafaide_explain_ruling` ([Coding agents](/docs/coding-agents#the-mcp-tools)) or on the console's Rulings page ([Rulings](/docs/rulings)).

## What each tool takes

`signafaide_quickstart` takes `language` (`python`, `typescript` or `javascript`) and, optionally, `framework` (`plain`, `langchain`, `openai-agents` or `vercel-ai`).

`signafaide_explain_error` takes `code`.

`signafaide_check_auditor_link` takes `link`: the whole auditor link, or only its token. Only links that start with `https://signafaide.co.uk/app/audit/` are accepted. A link to any other address is refused, and no request is made to that address.

`signafaide_verify_pack` takes the pack as JSON text in `pack`. The customer's agent keys (`agent_keys`, the content of `agent-keys.json`) and signed head (`head`, the content of `head.json`) are optional. Without agent keys the client signature check cannot be independent and fails, as it does in the command-line verifier. In ChatGPT the three inputs can also be attached files (`pack_file`, `agent_keys_file`, `head_file`). The pack is checked against the service's own public keys, never against the keys inside the pack.

`signafaide_service_keys` takes nothing.

## What it never does

- It never returns the inputs or outputs of an agent's tool calls. The auditor link check and the pack check return check results, counts and names only.
- It never creates, changes or deletes anything: no sandbox, no project, no record, no link.
- It never asks for a password, an API key or a sign-in.
- It never makes a request to an address you give it, apart from downloading a file you attached in ChatGPT from ChatGPT's own file store.
- It does not look public timestamps up online. Where a check would need that, the check is reported as not checked. The command-line verifier runs it: [Verify](/docs/verify).
- It does not keep a pack you send. The pack is read in memory for the check and then dropped.

What the service records about a call is in the [privacy notice](/legal/privacy). The answers a tool gives to an AI assistant are then handled by that assistant's provider under its own terms.

## Limits

| limit | value | when it is reached |
|---|---|---|
| calls | 60 a minute from one network address | HTTP 429 and error code 4290, with the seconds to wait |
| pack verifications | 10 a minute from one network address, within the 60 | error code 4290, with the seconds to wait |
| request size | 10 MB, and 10 MB for each attached file | HTTP 413 and error code 4130 |
| verifications at once | 2 across the service; a call waits up to 3 seconds for a free place | error code 5030: try again in a few seconds |
| time for one verification | 20 seconds | error code 5040: check a smaller pack, or run the verify command on your own machine |

An auditor link that covers more than 50,000 records is described but not checked: download the pack from the link and run the verify command.

## Try it from a terminal

The tool list:

```bash
curl -s https://api.signafaide.co.uk/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

One tool call:

```bash
curl -s https://api.signafaide.co.uk/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"signafaide_explain_error","arguments":{"code":"invalid_key"}}}'
```

The text of the answer:

```text
invalid_key (HTTP 401)
What it means: The API key is missing, malformed or revoked, or it is the key of a sandbox that nobody claimed before it expired: the service deletes such a sandbox and its records there, and its key with them.
How to fix it: Check SIGNAFAIDE_API_KEY in the environment or `.env`. Remove it and run `signafaide init` to create a new sandbox (then claim it: `signafaide status` shows the link and the days left), or paste a live key from the console. Records on this machine are kept and still verify.
Docs: https://signafaide.co.uk/docs/errors#invalid_key
```

A pack check, with the pack and the agent keys in files next to it:

```bash
jq -n --rawfile pack pack.json --rawfile keys agent-keys.json \
  '{jsonrpc:"2.0",id:3,method:"tools/call",params:{name:"signafaide_verify_pack",arguments:{pack:$pack,agent_keys:$keys}}}' \
  | curl -s https://api.signafaide.co.uk/mcp \
      -H 'content-type: application/json' \
      -H 'accept: application/json, text/event-stream' \
      -d @- | jq -r '.result.content[0].text'
```

The server speaks MCP protocol versions 2026-07-28, 2025-11-25, 2025-06-18 and 2025-03-26. It accepts POST only.
