# Maileroo MCP

> Maileroo connects your AI agent to an SMTP relay and API for transactional email. It lets you send emails, verify recipient addresses before sending, and track delivery status right from conversation. Use it when reliable inbox placement and scalable email operations matter.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** transactional-email, smtp-relay, email-verification, bounce-management, api-integration, deliverability

## Description

You gotta connect your AI agent right here to Maileroo. This server gives your client access to an SMTP relay and a full API, letting you run all your transactional email stuff straight from the chat window. Use this if reliable inbox placement or massive-scale sending operations are what's keeping you up at night.

When you use this setup, your agent handles everything—from verifying addresses before they even leave your system to tracking exactly where those emails land after they go out. You get real visibility into the entire email lifecycle without leaving your conversation pane.

Your client can **`send_transactional_email`**, which sends an actual message using a template you've already set up and a specific subject line. This is how you push out welcome sequences, password resets, or anything else that needs to hit the inbox fast and clean. 

Before sending anything, your agent can check domain details with **`get_domain_details`**. You feed it any domain name—sending or receiving—and it spits out all the technical specs you need to know about it. It's a quick way to make sure the handshake works.

If you wanna see what templates you've cooked up, run **`list_email_templates`**. This pulls up every email template you’ve created and are ready to drop into a message.

To keep track of where your mail is going, you can check recent sending activity using **`list_sending_activity`**. It gives you logs of everything you've sent out recently—the status codes, the timestamps, the whole deal. You see if it went through or where it got stuck.

You also need to know what domains are legit for sending. Run **`list_sending_domains`** and it fetches a list of every domain currently authorized on your Maileroo account. If you're trying to send from something new, you gotta make sure the domain shows up here first.

Want to see all the endpoints set up? Use **`list_configured_webhooks`**. This lists every single webhook URL that’s registered on your Maileroo account, so you know exactly what outside services are listening for those notifications. It's crucial housekeeping stuff.

When everything's running right, your agent can combine these tools: it can use **`list_email_templates`** to grab a clean template name, then run **`send_transactional_email`** to dispatch the message, and immediately follow up by checking the results with **`list_sending_activity`**. This means you're sending, tracking, and confirming all in one shot. You don't have to jump between five different dashboards; your AI agent handles it right here.

## Tools

### get_domain_details
Gets technical details for a specific domain name you need to check.

### list_sending_activity
Lists logs of your recent sending activity, including status and timestamps.

### list_sending_domains
Retrieves a list of all the domains currently authorized for sending emails from your account.

### list_email_templates
Retrieves a list of email templates you have created and can use to build messages.

### list_configured_webhooks
Lists all the webhook endpoints that are set up on your Maileroo account.

### send_transactional_email
Sends an actual email to recipients using a specified template and subject line.

## Prompt Examples

**Prompt:** 
```
Verify an email address and send a welcome email.
```

**Response:** 
```
Verified! ✅ sarah@company.com — Valid, deliverable, no disposable domain. MX records: OK. Email sent! To: sarah@company.com. Subject: 'Welcome to our platform'. Template: 'welcome_v2'. Status: Delivered ✅ (1.2s). Message ID: msg_4521.
```

**Prompt:** 
```
Show delivery analytics and bounce report.
```

**Response:** 
```
Delivery (7 days): 1,245 sent. Delivered: 1,208 (97% ✅). Bounced: 28 (2.2%). Soft: 18, Hard: 10. Complaints: 3 (0.2%). Avg delivery time: 1.8s. Suppression list: 45 addresses. Top bounce domain: outlook.com (8).
```

**Prompt:** 
```
Bulk verify a list of 5 email addresses.
```

**Response:** 
```
Bulk verification complete! 5 addresses. ✅ Valid: 3 (sarah@company.com, mike@techco.io, lisa@startup.com). ⚠️ Risky: 1 (info@temp-mail.org — disposable domain). ❌ Invalid: 1 (john@nonexistent.xyz — MX not found). Recommendation: Remove 1 invalid, flag 1 risky.
```

## Capabilities

### Send transactional emails
Sends an email using a specific template and recipient list.

### Check domain details
Retrieves technical information about any specified sending or receiving domain.

### Review configured webhooks
Lists all the webhook endpoints currently set up on your Maileroo account.

### List available email templates
Retrieves a list of email templates you have created and can use for sending.

### Check recent sending activity
Provides a log of your most recently sent emails, including status and timing.

### List active sending domains
Retrieves a list of all the domains authorized for sending email from your account.

## Use Cases

### User signs up, but we must confirm email validity first.
A new user provides an email. Instead of just sending a welcome message, your agent first runs `get_domain_details` to check the domain's health. If it passes, the agent then uses `send_transactional_email` with the 'welcome' template. Problem solved: we know the address is good and the user got their confirmation.

### Campaign launch needs immediate performance tracking.
After sending a large batch of password resets, an ops engineer asks for a report. The agent runs `list_sending_activity` and summarizes the results: 97% delivered, 2.2% bounced. This gives actionable metrics without logging into the web dashboard.

### We are updating our email branding and need to audit templates.
A product team member wants to know what templates exist for legal updates. The agent executes `list_email_templates` and provides a list of available IDs. They can then confirm the correct template ID before running `send_transactional_email`.

### Need to verify domains for a new partner integration.
A developer needs to ensure their partner's domain is ready for sending. The agent uses `get_domain_details` on the partner's domain, validating MX records and other necessary info before writing any code that relies on that connection.

## Benefits

- Send emails reliably every time. The `send_transactional_email` tool uses an SMTP relay built for scale, ensuring your messages don't get lost in the spam folder.
- Stop guessing about email addresses. Use validation tools to check if a recipient is valid and deliverable *before* you write the message. This cuts down on bounces immediately.
- Full visibility into sending health. `list_sending_activity` gives you immediate access to logs, allowing your agent to report delivery rates and average send times instantly.
- Manage branding without leaving chat. The `list_email_templates` tool lets your agent confirm which templates are available so you can trigger a consistent message every time.
- Audit your setup quickly. You don't need to jump through three different dashboards; tools like `get_domain_details` and `list_sending_domains` give you the facts right where you work.

## How It Works

The bottom line is: You use your agent to tell it what needs sending; the server handles the relaying, tracking, and reporting back the results.

1. Subscribe to the Maileroo server and input your unique API key.
2. Your AI agent calls one of the exposed tools, like `send_transactional_email`, with necessary parameters (e.g., recipient list, template ID).
3. Maileroo processes the request, sends the email via its relays, and returns a status object detailing success, failure, or delivery metrics.

## Frequently Asked Questions

**How do I check if an email address is good before running `send_transactional_email`?**
You run validation first. Use the underlying mechanisms to verify addresses and ensure they are deliverable. This prevents failed sends and improves your overall domain reputation.

**What tools do I use for tracking delivery metrics with Maileroo MCP Server?**
For logs, run `list_sending_activity`. For general health checks, you can check the status by listing recent sending activity and reviewing bounce/complaint data.

**Can I use the `get_domain_details` tool for anything other than validation?**
You can use it to pull technical information on any domain. This is useful if you're integrating with a partner and need to confirm their MX records or general domain setup.

**Does `send_transactional_email` require me to know the template ID?**
Yes, it does. You should first run `list_email_templates` to get a list of available templates and confirm the correct ID before attempting to send.

**What happens if I need to check my credentials or API access before running `send_transactional_email`?**
You must ensure your Maileroo API key is active and correctly configured in your client. If sending fails, the error message points directly to an authentication issue. Always verify the key against your account settings first.

**How does `list_sending_domains` help me manage my overall delivery health?**
It shows every domain you're currently using for sending emails. You can use this list to check if any domains are flagged, retired, or need updated authentication credentials before attempting a send.

**If I run `send_transactional_email` and receive multiple hard bounces, what should I do next?**
Hard bounces mean the email address doesn't exist. The system handles this by automatically adding the failed addresses to your suppression list. Never try to resend to an address that has bounced more than once.

**Can I use `list_configured_webhooks` to automate my delivery monitoring outside of a chat client?**
Yes, listing webhooks shows you the endpoints where Maileroo sends real-time updates. You can connect these URLs to your own internal systems for custom logging or automated alerts.

**Can I send transactional emails and verify addresses?**
Yes. Send emails with templates and verify addresses for deliverability before sending.

**How does Maileroo authentication work?**
Maileroo uses a custom **X-API-Key** header against `api.maileroo.com/v1`.

**Can I track bounces and delivery rates?**
Yes. Monitor bounce rates, complaints, suppressions, and overall delivery metrics.