# Postmark

> Send transactional email from an AI agent — verified deliverability, audit-friendly.

[Canonical HTML page](https://top-mcps.com/mcp/postmark) · [server.json](https://top-mcps.com/mcp/postmark.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "postmark": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "POSTMARK_SERVER_TOKEN",
        "-e",
        "POSTMARK_FROM",
        "postmarkapp/mcp-server:latest"
      ],
      "env": {
        "POSTMARK_SERVER_TOKEN": "${POSTMARK_SERVER_TOKEN}",
        "POSTMARK_FROM": "${POSTMARK_FROM}"
      }
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
# export POSTMARK_SERVER_TOKEN=changeme
# export POSTMARK_FROM=agent@example.com
claude mcp add postmark -- docker run --rm -i -e POSTMARK_SERVER_TOKEN -e POSTMARK_FROM postmarkapp/mcp-server:latest
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "postmark": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "POSTMARK_SERVER_TOKEN",
        "-e",
        "POSTMARK_FROM",
        "postmarkapp/mcp-server:latest"
      ],
      "env": {
        "POSTMARK_SERVER_TOKEN": "${POSTMARK_SERVER_TOKEN}",
        "POSTMARK_FROM": "${POSTMARK_FROM}"
      }
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "postmark": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "POSTMARK_SERVER_TOKEN",
        "-e",
        "POSTMARK_FROM",
        "postmarkapp/mcp-server:latest"
      ],
      "env": {
        "POSTMARK_SERVER_TOKEN": "${POSTMARK_SERVER_TOKEN}",
        "POSTMARK_FROM": "${POSTMARK_FROM}"
      }
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "postmark": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "POSTMARK_SERVER_TOKEN",
        "-e",
        "POSTMARK_FROM",
        "postmarkapp/mcp-server:latest"
      ],
      "env": {
        "POSTMARK_SERVER_TOKEN": "${POSTMARK_SERVER_TOKEN}",
        "POSTMARK_FROM": "${POSTMARK_FROM}"
      }
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "postmark": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "POSTMARK_SERVER_TOKEN",
        "-e",
        "POSTMARK_FROM",
        "postmarkapp/mcp-server:latest"
      ],
      "env": {
        "POSTMARK_SERVER_TOKEN": "${POSTMARK_SERVER_TOKEN}",
        "POSTMARK_FROM": "${POSTMARK_FROM}"
      }
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "docker",
          "args": [
            "run",
            "--rm",
            "-i",
            "-e",
            "POSTMARK_SERVER_TOKEN",
            "-e",
            "POSTMARK_FROM",
            "postmarkapp/mcp-server:latest"
          ],
          "env": {
            "POSTMARK_SERVER_TOKEN": "${POSTMARK_SERVER_TOKEN}",
            "POSTMARK_FROM": "${POSTMARK_FROM}"
          }
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.postmark]
command = "docker"
args = [
  "run",
  "--rm",
  "-i",
  "-e",
  "POSTMARK_SERVER_TOKEN",
  "-e",
  "POSTMARK_FROM",
  "postmarkapp/mcp-server:latest",
]
env = { POSTMARK_SERVER_TOKEN = "${POSTMARK_SERVER_TOKEN}", POSTMARK_FROM = "${POSTMARK_FROM}" }
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "postmark": {
      "command": {
        "path": "docker",
        "args": [
          "run",
          "--rm",
          "-i",
          "-e",
          "POSTMARK_SERVER_TOKEN",
          "-e",
          "POSTMARK_FROM",
          "postmarkapp/mcp-server:latest"
        ]
      },
      "env": {
        "POSTMARK_SERVER_TOKEN": "${POSTMARK_SERVER_TOKEN}",
        "POSTMARK_FROM": "${POSTMARK_FROM}"
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Postmark doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Community
- **Transport:** stdio
- **Auth model:** API key
- **Required secrets:** POSTMARK_SERVER_TOKEN, POSTMARK_FROM
- **Supported clients:** Claude, Cursor, VS Code, Windsurf, Any MCP-compatible client, Postmark account
- **License:** MIT
- **Language:** TypeScript
- **Latest version:** latest
- **Last verified:** 2026-06-02
- **Score:** 59/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/postmark-mcp/postmark-mcp

## Tools & permissions

| Tool | Description | Args | Side effects |
|------|-------------|------|--------------|
| `send_email` | Send a transactional email. | `to: string, subject: string, body: string` | write |
| `send_template` | Send a templated transactional email. | `template_id: string, to: string, model: object` | write |
| `get_message` | Look up a sent message by ID. | `message_id: string` | read |
| `search_messages` | Search the message stream by recipient, status, or tag. | `query: object` | read |

## Security & scope

- **Access scope:** read-write
- **Sandbox:** Authenticates with a Postmark server token scoped to one logical send domain. The MCP exposes message-send and read-stream tools; rate-limited per token.
- **Gotchas:**
  - Server tokens can send email — treat them as production secrets and rotate on team changes.
  - POSTMARK_FROM must match a verified sender signature in the Postmark account, or sends 422.
  - Agent-drafted email can still hallucinate addresses — gate the send tool through a human approval step for high-blast-radius flows.

## Quick answer

**What it does.** Wraps the Postmark REST API: send a transactional email, query message status, search the message stream, fetch bounce details, list servers and templates.

**Best for:**
- Transactional email from agents
- Customer notifications
- Internal alert routing
- Bounce and complaint triage
- Template-driven sends

**Not for:**
- Marketing campaigns
- Cold outreach
- Newsletter blasts

## Description

The Postmark MCP connects an AI agent to a Postmark server token. Send transactional email, look up message status, search the message stream for bounces and complaints, and inspect server-level statistics. Postmark's strict transactional-only policy makes it a safer default than general SMTP relays for agent-driven send because the model cannot accidentally trigger marketing sends.

## Why it matters

Transactional email from agents is the most common "agent does something in the real world" workflow. Postmark's separation of transactional and broadcast traffic means an agent cannot get pulled into a marketing-blast incident.

## Key features

- Transactional-only — no marketing risk
- Server token scoping
- Template send + raw send
- Message stream search
- Bounce + complaint inspection

## FAQ

### Server token or account token?

Server token. Each Postmark "server" is a logical send domain; the MCP scopes by server token so the agent can never reach a production server it was not authorised for.

### Can it send marketing email?

No. Postmark refuses non-transactional traffic. For marketing or broadcast use a separate broadcast tool — the agent cannot accidentally cross that line on Postmark.

### How does it handle bounces?

The message stream tool surfaces bounce class (Hard, Soft, Spam, Block) and the agent can read the bounce details. For automatic suppression list management call the bounce-deactivate tool.

## Changelog

- **2026-06-02** — Refreshed install snippets and fact sheet; verified for 2026.
- **2025-02-12** — Initial directory listing.
