Mailtrap MCP for AI. Test, Debug, and Analyze Email Delivery Safely.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
How this MCP server connects to your AI agent
Mailtrap connects your AI agent to a full email sandbox environment. It lets you send, test, and debug transactional emails in staging before they hit production.
You can inspect captured emails, analyze spam scores, track bounces, and manage multiple projects without ever sending anything live. This is for developers who need proof that an email looks right everywhere.
What AI agents can do with Mailtrap Automation
Clear sandbox inbox
Deletes all captured emails from a specific sandbox inbox.
Delete sandbox message
Removes one captured email message from the sandbox history.
Get domain status
Retrieves detailed status and verification information for your sending domains.
Your agent sends an email using send_test_email, which routes the message only to your controlled testing inboxes.
You use get_message_html to retrieve the full, unparsed HTML source code from a specific sandbox message for deep inspection.
The agent calls get_domain_status to verify if your sending domains are set up correctly, checking required details like SPF/DKIM records.
You use list_sandboxes to see a summary of every virtual inbox or project you manage within Mailtrap.
The agent triggers send_production_email, which sends the message out through your verified sending domains, simulating live delivery.
Ask an AI about this
Waiting for input…
What AI agents can do with Mailtrap MCP Server: 12 Tools for Email Sandboxing
Use these tools to manage every phase of email communication—from listing projects and checking domain status to sending test emails and analyzing captured message content.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Mailtrap on VinkiusClear Sandbox Inbox
Deletes all captured emails from a specific sandbox inbox.
Delete Sandbox Message
Removes one captured email message from the sandbox history.
Get Domain Status
Retrieves detailed status and verification information for your sending domains.
Get Message Html
Retrieves the full, raw HTML body of any saved email message.
Get Message Details
Fetches metadata about a specific captured message, including spam score and headers.
List Accessible Accounts
Lists all Mailtrap accounts connected to this API key.
List Verified Domains
Shows a list of all sending domains that are currently verified and ready for use.
List Sandboxes
Lists every virtual, accessible testing sandbox you have set up.
List Sandbox Messages
Shows a summary list of all messages currently captured in an inbox.
List Mailtrap Projects
Retrieves a list of active projects and sandboxes within your account.
Send Production Email
Sends an email immediately through your live, verified production channels.
Send Test Email
Sends a non-live test email that lands only in the sandbox for inspection.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Mailtrap integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Mailtrap, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Mailtrap. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 12 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Debugging email delivery shouldn't require an admin console login.
Right now, verifying a complex transactional email means jumping between your code editor, the SMTP service dashboard, and maybe even opening your personal inbox just to see if it arrived. You copy headers here, check spam scores there, and manually compare HTML snippets in five different tabs.
With this MCP server, you tell your agent what needs checking: 'Check the email for Invoice #890.' The agent uses `get_message_details` and `list_sandbox_messages` to pull everything—spam score, headers, content structure—and presents it all in one conversation. No jumping around.
Mailtrap MCP Server: Get proof of delivery with send_test_email.
Manually running tests means either sending real emails (wasting credits or alarming users) or relying on limited, basic local mocking. You can't simulate the full complexity—the headers, the bounces, the multiple domain checks.
The agent handles it all. It uses `send_test_email` to safely deliver the message into your sandbox. Then, using tools like `get_message_html`, you get perfect data back. You prove delivery and structure without ever touching a live inbox.
What your AI can actually do with this
This server connects your AI agent directly to Mailtrap's sandbox environment. You're outta guessing if your emails look right; you test 'em in a safe zone before they hit any real inbox. It lets your agent send, inspect, and debug transactional messages without ever touching live production channels.
Getting Set Up and Listing Environments
You start by letting your agent check what accounts are available using list_accessible_accounts, which shows every Mailtrap account linked to this API key. You can then see all the active projects and sandboxes you're managing with list_mailtrap_projects. If you need a quick overview of everything, list_sandboxes returns a list of every virtual testing sandbox you've set up.
Before sending anything, your agent can check which domains are good to go using list_verified_domains, giving you a rundown of all the sending domains that have been fully verified and are ready for use. You'll also get proof on your domain setup by calling get_domain_status; this function retrieves detailed status and verification information, confirming required details like SPF or DKIM records.
Sending Test Messages vs. Live Mail
When you need to test a message, your agent triggers send_test_email. This sends a non-live email that lands only in the controlled sandbox for inspection, keeping it safe from real people. If you're actually ready to send something live through verified channels, the agent uses send_production_email to fire the message out immediately.
Inspecting and Debugging Captured Emails
The heart of this server is debugging what got captured. First, your agent runs list_sandbox_messages, which provides a summary list showing all messages currently sitting in an inbox. Once you know there's a message there, you can pull the full metadata using get_message_details. This function fetches key details about that specific captured message, including its spam score and headers for immediate analysis.
If you need to see exactly how the email was structured on the front end, you use get_message_html to retrieve the full, raw HTML body of any saved message; this is crucial for deep debugging. You can also get a clean list of all sandboxes using list_sandboxes, and if you need to check what's in a specific inbox, your agent can run list_mailtrap_projects to help navigate the captured messages.
Managing and Cleaning Up Sandboxes
When testing is done, you gotta clean up. If an entire sandbox inbox is cluttered with old test data, your agent uses clear_sandbox_inbox to delete every single captured email from that specific sandbox. If it's just one message that's garbage or needs removing, the agent can call delete_sandbox_message, which removes a single captured email from the sandbox history.
This gives you complete control over your testing environment.
019dd11e-e565-7355-bb95-ef7ab3b4a789 
Here's how it actually works
The bottom line is: you treat email testing like debugging code—you inspect the input (the HTML), check the environment (domain status), and verify the output (message data) before deployment.
First, give your AI client the Mailtrap API Key and Account ID. This connects it to your sandbox.
Next, run a discovery tool like list_sandboxes to see what testing environments are available for this project.
Finally, use tools such as get_message_details on a specific message ID. The agent pulls the metadata (spam score, headers) and presents it right in your chat.
Who is this actually for?
Developers, QA Engineers, and Operations staff. This is for anyone whose job depends on sending reliable communications—whether it’s a password reset link or a marketing newsletter. If you get frustrated checking if an email looks good across different clients (Outlook vs. Gmail), this server is built for your pain.
You use the agent to trigger send_test_email after implementing a new API endpoint, then run get_message_html to verify the payload structure.
You check email rendering and spam scores by running list_sandbox_messages, confirming that edge cases (like images in plain text) display correctly, then use get_message_details for the full report.
You monitor production delivery rates using analytics tools and verify domain setup by calling get_domain_status before any major release.
What Changes When You Connect
Stop guessing if your emails look right. Use get_message_html to inspect the raw source code of captured messages, guaranteeing consistency across clients.
Manage complexity with list_sandboxes. You can keep dedicated testing inboxes for different features (e.g., 'Signup Flow' vs. 'Password Reset') without mixing data.
Catch failure before sending. Before using send_production_email, check the domain health first by calling get_domain_status to verify your credentials are solid.
Deep dive into bounces and opens. The system tracks crucial delivery metrics, allowing you to analyze open rates and click paths from historical data.
Control your environment completely. Use list_sandbox_messages to see a quick list of what's captured, or delete_sandbox_message if the record is stale.
See it in action
Verifying a new signup email template.
The marketing team changes the newsletter design. Instead of sending it to 10,000 people and dealing with complaints, they use their agent to run send_test_email. They then ask the agent to call get_message_html on the resulting message in the sandbox. This confirms the new CSS structure works before any code hits production.
Debugging a failed password reset link.
A user reports the 'Forgot Password' email is broken. The agent first uses list_accessible_accounts to select the correct environment, then triggers send_test_email. They check get_message_details on the captured message and see a low spam score or missing headers, pinpointing the exact failure point.
Auditing domain readiness for a migration.
The ops team is moving to a new sender domain. They don't want failed sends. The agent first runs list_verified_domains and then calls get_domain_status. If the status shows any gaps, they fix them before attempting to use send_production_email.
Analyzing a batch of captured emails.
A QA engineer needs to check 50 messages from last night's test run. Instead of manually clicking into each one, they tell their agent to use list_sandbox_messages for an overview, then loop through the IDs using get_message_details to quickly compare spam scores and headers.
The honest tradeoffs
Running production sends without pre-checks
Just calling send_production_email because 'it seems fine.' This risks sending emails that fail due to outdated DNS records or incorrect account credentials.
Always run this in stages. First, call list_verified_domains and then get_domain_status. Only if the status passes all checks should you use send_production_email.
Assuming the sandbox is clean
Relying on an inbox being empty when starting a new test. You might accidentally analyze old, irrelevant messages.
Start by calling clear_sandbox_inbox to wipe out all previous data. This ensures your agent only analyzes current testing results.
Only looking at the sender side
Confirming that you sent the email, but failing to check if the recipient client (like Outlook) corrupted the HTML.
Always use get_message_html on a captured message. This lets you inspect the payload's raw code and verify the structure of the content.
When It Fits, When It Doesn't
Use this server if your job requires absolute proof that an email looks identical in staging, testing, and production environments. You need to validate HTML integrity, check bounce rates, or manage multiple test accounts—the whole lifecycle. Don't use it if all you need is a simple message queue for delivery confirmation; those tools are overkill. If you only need basic rate limiting monitoring without content inspection, look at dedicated SMTP log aggregators instead. But because this server gives you the full stack (sending, status checks via get_domain_status, and deep inspection via get_message_html), it handles everything from initial development proof-of-concept to final ops verification.
Questions you might have
How do I check if my domains are set up correctly with Mailtrap MCP Server? +
You call the get_domain_status tool. This function checks your domain's current status, verifying things like SPF and DKIM records against best practices.
What is the difference between send_test_email and send_production_email? +
send_test_email sends a non-live message that only appears in your secure sandbox. send_production_email uses your live, verified credentials to deliver mail out into the real world.
Can I see the raw source code of an email using Mailtrap MCP Server? +
Yes, use get_message_html. This tool pulls the complete, unparsed HTML body of a captured message, which is essential for QA checks.
How do I find all my available testing environments with Mailtrap MCP Server? +
You run list_sandboxes. This command gives you an immediate list of every virtual inbox or project you can target for sending tests and inspection.
How do I use the `clear_sandbox_inbox` tool with Mailtrap MCP Server? +
It immediately deletes all emails from your current sandbox inbox. This is useful when you need a clean slate before running a new test flow, ensuring old messages don't confuse your debugging process.
What kind of metadata does `get_message_details` provide via Mailtrap MCP Server? +
It gives you core message metadata like headers, bounce status, and detailed spam scores. This lets you debug why an email might fail delivery before it reaches a real user.
How does the Mailtrap MCP Server manage multiple client accounts? +
The server allows you to list available accounts and switch between them within your agent. You don't have to reconfigure your AI client when testing different development environments or domains.
Can I verify my sending domain setup using Mailtrap MCP Server? +
You use the domain status tools to check for authentication issues. This confirms that your external sending domain is properly set up and ready for both test and production email sends.
Can I both test and send emails with Mailtrap? +
Yes. Mailtrap supports both Email Testing (capturing emails in staging) and Email Sending (transactional delivery in production).
Does Mailtrap require an Account ID? +
Yes. You need both an API Key and Account ID to authenticate via Bearer token against mailtrap.io/api.
Can I analyze spam scores and HTML rendering? +
Yes. Mailtrap analyzes captured emails for spam score (SpamAssassin), blacklists, HTML errors, and client support.
We've already built the connector for Mailtrap. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 12 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.