Connect GitHub Copilot to Postal

Check these points before opening the GitHub Copilot setup. They prevent most connection failures.

• A team with the "MCP server" plan feature (mcp_access); without it the server responds 403 plan_limit_reached.
• To send emails, the team needs at least one verified domain.
• If you will use an API key: create the key in the dashboard, under API keys. It starts with ps_; a send-only key is enough if you will only send.
• Each connection acts on a single team. To use another team, connect again and pick the other one.
• Connections are listed under Settings › AI connections in the dashboard, where they can be revoked at any time.

Follow the steps in order. The server address is always https://api.postal.so/mcp. Recommended path: sign in with your account (OAuth). The API key is the alternative. Wherever ps_... appears, use your own API key: the value shown is only an example.

1. 1

   VS Code (Copilot Chat): create .vscode/mcp.json in the project (or run the "MCP: Add Server" command and choose HTTP) with the first block.

2. 2

   Click Start above the server in the file; VS Code opens the Postal OAuth login. Choose the team and click Allow.

3. 3

   In Copilot Chat, select Agent mode and check the tool list (MCP: List Servers).

4. 4

   With an API key in VS Code, use the second block: VS Code asks for the key when it starts the server.

5. 5

   Copilot CLI: run the command in the third snippet. Copilot cloud agent (GitHub): under the repository's Settings > Copilot > MCP servers, paste the JSON from the fourth snippet and create the secret (or variable) COPILOT_MCP_POSTAL_API_KEY in the repository's Agents settings (only names starting with COPILOT_MCP_ are available); this agent does not support remote servers with OAuth.

{
  "servers": {
    "postal": {
      "type": "http",
      "url": "https://api.postal.so/mcp"
    }
  }
}

{
  "inputs": [
    {
      "type": "promptString",
      "id": "postal-api-key",
      "description": "Postal API key",
      "password": true
    }
  ],
  "servers": {
    "postal": {
      "type": "http",
      "url": "https://api.postal.so/mcp",
      "headers": {
        "Authorization": "Bearer ${input:postal-api-key}"
      }
    }
  }
}

copilot mcp add --transport http --header "Authorization: Bearer ps_..." postal https://api.postal.so/mcp

{
  "mcpServers": {
    "postal": {
      "type": "http",
      "url": "https://api.postal.so/mcp",
      "tools": [
        "list_domains",
        "get_domain",
        "list_emails",
        "get_email",
        "get_usage"
      ],
      "headers": {
        "Authorization": "Bearer $COPILOT_MCP_POSTAL_API_KEY"
      }
    }
  }
}

Postal splits access into three levels, explained in the scopes table. For GitHub Copilot:

The simplest proof is to ask for something read-only inside GitHub Copilot itself. The connection also shows up under Settings › AI connections in the Postal dashboard, with the app, the team and the last use.

For those who want the technical proof

npx @modelcontextprotocol/inspector --cli https://api.postal.so/mcp \
  --transport http \
  --header "Authorization: Bearer ps_..." \
  --method tools/list

The Inspector proves that the Postal server responds. It does not test GitHub Copilot itself. The full walkthrough is in Validate the connection.

Go through the list in order. Then read what we know (and what we don't know) about GitHub Copilot.

What was tested and what was not