# MailerSend MCP

> MailerSend lets your agent send transactional emails and manage sender domains directly through natural language prompts. It handles both single sends and large batches of emails up to 500 recipients at a time. Use it to check domain verification status, track real-time email activity logs, or query recipient details from your account database.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** transactional-email, email-delivery, domain-management, bulk-email, api-integration

## Description

This MCP connects your agent to the MailerSend API, giving you control over transactional messaging and domain health without touching a dashboard. You can automate everything from sending single emails using templates to running massive batch operations for high-volume campaigns. It gives you visibility into email delivery performance by listing all sender domains and triggering ownership verification checks when needed. Need to know who opened an email or if it bounced? Your agent pulls real-time logs, letting you access event activity for any domain or retrieve complete metadata on a specific sent message. Plus, you can query your account database using list_email_recipients to ensure your campaign lists are always accurate. All this goes through your AI client and is available via the Vinkius Catalog.

## Tools

### get_sender_domain_details
Pulls specific technical details about a single sender domain you own.

### get_sent_message_details
Retrieves the complete history and metadata for one particular sent email.

### get_recipient_details
Gets specific data points about a single recipient from your linked database.

### list_domain_activity
Compiles all email activity, including opens and clicks, for an entire domain ID.

### list_sender_domains
Shows a comprehensive list of all domains you have registered with MailerSend.

### list_sent_messages
Generates a full catalog listing every email message that has been sent through your account.

### list_email_recipients
Retrieves the entire list of contact records currently stored in your account database.

### send_bulk_transactional_emails
Sends multiple transactional emails at once, processing them as a single batch request.

### send_transactional_email
Sends one individual email using specified sender, recipient, and content or template ID.

### verify_sender_domain
Initiates a DNS verification check to confirm ownership of a sending domain.

## Prompt Examples

**Prompt:** 
```
Send a transactional email to 'user@example.com' with subject 'Welcome' and body 'Hello!'.
```

**Response:** 
```
I've sent the email to user@example.com. The message ID is '64f1abcde12345'. MailerSend has queued the delivery.
```

**Prompt:** 
```
List all active sender domains in my account.
```

**Response:** 
```
I've retrieved your domains. You have 2 verified domains: 'mail.example.com' and 'updates.myfirm.io'. Would you like to check the DNS settings for any of them?
```

**Prompt:** 
```
Show recent opened events for domain ID '98765'.
```

**Response:** 
```
I found 15 'opened' events for domain 98765 in the last 7 days. Most recent interactions were from 'customer@corp.com' and 'alice@test.io'.
```

## Capabilities

### Send single or bulk emails
Your agent sends transactional messages, supporting both single recipients and batches of up to 500 people.

### Manage sender domains
You list all associated sending domains, check their DNS settings, and trigger ownership verification checks.

### Audit email activity
The MCP provides real-time logs of email events like opens, clicks, and deliveries for any domain.

### Query message history
Your agent retrieves full metadata, including the entire lifecycle history for individual sent messages or lists all past sends.

### Find recipient details
You list and pull specific data about recipients directly from your linked account database.

## Use Cases

### Checking Compliance Before Launch
The ops engineer needs to launch a marketing campaign but isn't sure if their new sender domain is fully verified. They prompt the agent: 'Check my domain status.' The agent runs verify_sender_domain and reports back on the current DNS requirements, stopping potential delivery issues before they start.

### Handling Large User Onboarding
The development team needs to notify 500 users immediately upon sign-up. Instead of writing a complex loop, they instruct their agent to 'Send welcome emails to the entire user list.' The agent uses send_bulk_transactional_emails, completing the task in one go.

### Investigating Delivery Failures
A client complains that some recipients didn't get an email. They ask the agent to 'Show all activity for last week.' The agent runs list_domain_activity, quickly pinpointing which specific domain ID had delivery failures and why.

### Auditing Campaign Performance
The marketing analyst needs proof of campaign success. They prompt: 'Find the activity for messages sent last month.' The agent runs list_sent_messages, allowing the analyst to get_recipient_details and build a complete performance report.

## Benefits

- Confirm Domain Ownership: Instead of manually navigating DNS records, you run the verify_sender_domain tool to instantly trigger ownership checks for your sending domain.
- High-Volume Sending: You can process thousands of contacts quickly by using send_bulk_transactional_emails, eliminating the need for manual API calls per recipient.
- Full Audit Trail: When a campaign goes sideways, you don't guess. Use list_domain_activity to pull real-time logs and see exactly when opens or clicks happened.
- Data Synchronization: You can use list_email_recipients to ensure your mailing list is always accurate by pulling the most current contact records before sending anything.
- Deep Message Insight: To troubleshoot a specific email, you run get_sent_message_details. This pulls every piece of metadata about that one message's lifecycle.

## How It Works

The bottom line is that you manage complex email workflows using simple natural language instructions from any compatible client.

1. Subscribe to the MailerSend MCP and input your API token into Vinkius.
2. Your agent reads the prompt (e.g., 'Check domain activity for X') and determines which tool is needed.
3. The MCP executes the request, returning structured data about domains, sent messages, or recipient lists directly to your AI client.

## Frequently Asked Questions

**How do I check if my sending domain is authorized using MailerSend MCP?**
Run verify_sender_domain. This tool triggers a DNS verification check, confirming ownership status and letting you know what records are needed to get started.

**Can I send emails to more than 500 people with MailerSend MCP?**
No, the current bulk sending limit is 500 recipients per single batch request. If you have thousands of contacts, your workflow needs to be segmented into multiple batches.

**What information does list_domain_activity provide about my emails?**
It provides real-time logs detailing every email event for a domain ID, including when it was opened, clicked, or delivered. This is crucial for performance auditing.

**How do I find out why an individual message failed to send using MailerSend MCP?**
Use get_sent_message_details. This tool fetches the complete metadata and lifecycle history for that specific message, pinpointing exactly where the failure occurred.

**Does list_email_recipients pull all my contacts from the web?**
No, it queries only the contact records stored in your linked account database. It's a reliable way to ensure you are using up-to-date data for your campaigns.