# Postmark MCP

> Postmark MCP lets your AI agent manage and analyze every part of your transactional email pipeline. Send emails using pre-set templates or raw HTML; check out detailed bounce logs (Hard/Soft Bounces); review server analytics like open rates, and query message history—all without logging into the Postmark UI.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** transactional-email, smtp, email-delivery, bounce-tracking, api-integration, email-templates

## Description

Your AI agent uses this MCP to fully manage your application's transactional email flow. Instead of relying on a web dashboard or writing boilerplate code, you ask your client to perform actions directly against your mail service. For instance, if you need to know why some users didn't get an update, you can query the bounce logs and pinpoint whether it was a hard failure or a block. You can also pull templates by name or ID, letting your agent review the raw HTML to make sure dynamic variables like `first_name` are placed correctly. The entire system is accessible through Vinkius, the #1 MCP Catalog, meaning you connect once from any compatible client and get full control over your email notifications right where you're already working.

## Tools

### get_bounces_overview
Retrieves a summary of your overall bounce statistics.

### get_server
Pulls basic operational details about the connected Postmark server instance.

### get_template
Fetches the specific code and structure for a single named email template.

### list_templates
Provides an index of all available templates configured on your server.

### get_outbound_overview
Retrieves general metrics and performance data for all outgoing messages.

### search_bounces
Searches your bounce logs, allowing filtering by type (Hard/Soft), specific email address, or message ID.

### search_outbound_messages
Queries the historical record of sent emails by filtering based on recipient, sender, or delivery status.

### send_email
Sends a basic transactional email using specified From/To addresses and either plain text or HTML content.

### send_email_with_template
Dispatches an email by applying the logic of a specific, pre-configured Postmark template.

## Prompt Examples

**Prompt:** 
```
Check the bouncing metrics for our transactional emails.
```

**Response:** 
```
I've analyzed your bounce metrics. The server currently has 14 Hard Bounces and 3 Soft Bounces within the query scope. Overall health looks good! Want me to list the specific emails?
```

**Prompt:** 
```
Can you fetch the HTML body layout of our 'Welcome' template?
```

**Response:** 
```
I found your 'Welcome' template (ID: 809214). It expects three variables: `first_name`, `action_url`, and `support_email`. The HTML renders a classic logo-centric email layout.
```

**Prompt:** 
```
Send a standard test email to alice@example.com using our current Postmark setup.
```

**Response:** 
```
The email has been processed! Postmark returned success mapping with a Message ID `f8a847a9-2169-45e0-...` indicating instantaneous dispatch.
```

## Capabilities

### Send emails via templates or raw HTML
Your agent sends transactional messages using either a pre-built Postmark template or custom, plain HTML/text.

### Analyze bounce failure logs
The MCP retrieves detailed data on why specific email recipients failed delivery, distinguishing between hard bounces and soft bounces.

### Review template structure
You can fetch the source code of any Postmark template to check its required variables or visual layout.

### Check delivery analytics overview
The agent pulls general stats on outbound messages, including open rates and overall system health metrics.

### Search specific message history
You query the full send history by filtering criteria like sender email address or delivery status.

## Use Cases

### A user notices a sudden spike in failed updates.
Instead of diving into the web console, they ask their agent to run `search_bounces`. The MCP immediately filters the logs and shows that 80% of the failures are 'recipient blocked' (Hard Bounces), letting them know the problem is address list hygiene, not code.

### A product manager needs to verify a new feature email layout.
They ask for `get_template` on the 'Welcome' message. The agent returns the raw HTML body and lists required variables (e.g., `first_name`), allowing them to approve the design without manual visual checks.

### A developer needs to confirm a critical test email sends correctly.
The developer prompts the agent to `send_email` to their QA colleague. The response confirms success and provides a Message ID, letting them commit code knowing the delivery mechanism worked perfectly.

### An admin needs an immediate health check on mailing volumes.
The admin asks for the `get_outbound_overview`. The agent pulls the current stats in seconds—a summary of open rates and message volume metrics—saving them 10 minutes of dashboard clicking.

## Benefits

- Stop checking dashboards. Instead, ask your agent to run `search_bounces` and tell you exactly which recipients are bouncing and why. You get the specific error code right in your chat window.
- When deploying a new feature, use the MCP to call `get_template` on critical emails. This lets you review the raw HTML structure, verifying that all dynamic variables will align perfectly with your codebase before deployment.
- Need to send a test message? Just ask it to `send_email_with_template`. You can confirm delivery instantly and get back the Message ID, proving the email was dispatched correctly without manual steps.
- Debugging is faster when you can query history. Use `search_outbound_messages` to filter by status or sender address, giving you a precise view of message flow that's hard to find in an admin UI.
- Get immediate health checks. The MCP allows querying the `get_outbound_overview` tool so your agent can summarize key metrics like open rates and general delivery performance instantly.

## How It Works

The bottom line is you get full control over your application's email notifications from anywhere, without needing to open another browser tab.

1. Subscribe to this MCP and provide your Postmark Server Token.
2. Your AI client accesses the tools through natural conversation (e.g., 'Check our bounce rate for last month').
3. The agent executes the necessary calls, retrieves the structured data (like a list of failed emails or template code), and presents it directly in the chat.

## Frequently Asked Questions

**How do I check bounce metrics using Postmark MCP?**
You use `get_bounces_overview` for a general summary of current bounces. If you need to investigate specific failures, run the `search_bounces` tool and filter by type (Hard or Soft) to pinpoint the exact error.

**Can Postmark MCP send emails with my custom code?**
Yes. You can use the `send_email` tool, which accepts raw HTML or plain text bodies, allowing you to bypass templates for specific testing scenarios.

**What if I want to check all my sent messages in Postmark MCP?**
Run the `search_outbound_messages` tool. This lets you filter by recipient or status, giving you a comprehensive look at your message history without manually browsing folders.

**Does Postmark MCP help with template debugging?**
Absolutely. Use `get_template` to fetch the raw HTML source code for any template. This lets you visually and structurally verify that all required variables are correctly implemented in the body.

**Is postmark-alternative MCP faster than using the Postmark UI?**
Yes, because it eliminates context switching. You stay within your preferred AI client environment (Claude, Cursor, etc.) and execute commands instantly via conversation rather than navigating a separate web interface.