MCP Email Server: 190 AI Agent Tools for Email Deliverability

AI agents can write code, query databases, manage calendars, and draft documents. But email remains a blind spot. There is no standardized way for an AI agent to validate an address, check DNS authentication, send a transactional message, process a bounce, or monitor sender reputation. Every integration is hand-built, and every workflow requires a developer in the loop.

The Model Context Protocol (MCP) changes this. Developed by Anthropic as an open standard, MCP gives AI agents a universal interface to external tools through JSON-RPC 2.0. Think of it as a USB port for AI: plug in a server, and the agent immediately discovers and can use every tool it exposes.

MailOdds ships a 190-tool MCP server covering the full email lifecycle. From single-email validation to bulk list hygiene, from DNS remediation to DKIM-signed transactional sends, from real-time telemetry to persistent Guardian Mode monitoring. 29 categories, zero external npm dependencies, sub-200ms response times. The email deliverability platform becomes something an AI agent can operate autonomously.

What is the Model Context Protocol?

MCP is an open standard that defines how AI agents communicate with external services. Built on JSON-RPC 2.0, it provides a structured protocol for tool discovery, invocation, and response handling. An MCP server exposes a set of tools with typed parameters and descriptions. An MCP client (the AI agent) connects, discovers available tools, and calls them as needed to complete tasks.

The protocol supports two transport mechanisms. Stdio transport runs the server as a local subprocess, communicating over standard input and output. This is how editors like Claude Code, Cursor, and VS Code connect. SSE (Server-Sent Events) transport runs the server as an HTTP endpoint, enabling web-based and hosted agents to connect over the network. Both transports use the same JSON-RPC 2.0 message format.

The practical difference between MCP and a traditional API integration is significant. With a REST API, a developer writes HTTP client code, handles authentication, parses responses, manages errors, and builds each workflow manually. With MCP, the agent receives tool definitions automatically and orchestrates multi-step workflows on its own. The developer configures the connection once. The agent does the rest.

Email is an ideal domain for MCP because the work is inherently multi-step. Fixing deliverability is not a single API call. It requires checking DNS records, diagnosing DMARC alignment, validating recipient lists, configuring suppression policies, sending authenticated messages, and monitoring delivery metrics. These are exactly the kind of sequential, decision-heavy workflows where AI agents excel. The MailOdds MCP server gives them the tools to do it. See the full email validation API and email sending API documentation for the underlying capabilities.

The 29 Categories: 190 Tools for the Full Email Lifecycle

The MCP server organizes its 190 tools into 29 functional categories. Each pillar handles a distinct phase of email operations:

Five tools deserve a closer look because they demonstrate the difference between raw API access and agent-native design.

onboarding_probe: Zero-Click Account Health

The first tool an agent should call after connecting. onboarding_probe returns a complete account health snapshot: sending domains with identity grades, 24-hour reject rates, policy audit results, and a prioritized list of recommendations. The agent gets everything it needs to diagnose problems without the user having to specify what to check.

{
  "greeting": "Connected to MailOdds. Here is your account health snapshot:",
  "account_summary": {
    "sending_domains": 2,
    "reject_rate_24h": "3.2%"
  },
  "domain_health": [
    { "domain": "mail.acme.com", "grade": "C", "score": 65 }
  ],
  "recommendations": [
    { "priority": "critical", "action": "Run remediate_domain on mail.acme.com" }
  ]
}

remediate_domain: Consultative DNS Diagnosis

When a domain grade is below B, remediate_domain performs a full DNS audit and returns copy-paste DNS records for every failing check. Not just "DMARC is missing" but the exact TXT record with the correct host, value, and TTL. The agent can present these directly to the user or, in automated pipelines, apply them through a DNS API. This connects directly to DMARC monitoring for ongoing compliance tracking.

{
  "grade": "C",
  "score": 55,
  "urgency": "high",
  "dns_records_to_add": [
    {
      "check": "DMARC",
      "type": "TXT",
      "host": "_dmarc.acme.com",
      "value": "v=DMARC1; p=quarantine; rua=mailto:dmarc@acme.com",
      "ttl": 3600
    }
  ]
}

validate_and_watch: Long-Polling Bulk Validation

For lists of any size, validate_and_watch combines job creation with live progress notifications. The agent submits the list and receives progress updates every 4 seconds until completion. With auto_suppress_high_risk: true, the tool automatically creates a domain blocklist policy for domains with 3 or more invalid or disposable emails, merging into existing policies instead of creating duplicates. This is the primary tool for the bulk validation workflow and works alongside validation policies.

safe_deliver: Pre-Validated AI-Optimized Sending

safe_deliver always runs with validate_first: true. Before sending, it validates the recipient address and blocks delivery to invalid or high-risk addresses. It also auto-generates an ai_summary from the HTML content, ensuring every email is optimized for AI inbox prioritization. Every message is DKIM dual-signed with both RSA and Ed25519 signatures. See the full email sending API and transactional email documentation for details.

Guardian Mode: Persistent Background Monitoring

subscribe_guardian activates persistent background monitoring that runs independently of tool calls. Once subscribed, Guardian polls telemetry and domain health on a configurable interval (30 seconds to 5 minutes, default 60 seconds) and emits alerts when thresholds are breached: reject rate above a limit, deliverable rate below a floor, or any domain grade dropping below the minimum. Alerts are deduplicated within a configurable window (default 5 minutes) to prevent notification floods. Guardian auto-pauses after 10 consecutive API failures and resumes automatically when connectivity returns. This integrates with sender reputation scoring, suppression list management, spam checking, blacklist monitoring, and email analytics.

{
  "guardian_key": "guardian:a1b2c3d4",
  "profile": "production",
  "alert": {
    "type": "telemetry_breach",
    "metric": "reject_rate",
    "value": 0.12,
    "threshold": 0.05,
    "direction": "above"
  }
}

Quickstart: Connect in Under a Minute

The MCP server installs with a single command and requires only one environment variable: your MailOdds API key. Get one from the dashboard (free tier includes 50 validations per month, no credit card required).

Claude Code

claude mcp add --transport stdio \
  -e MAILODDS_API_KEY=your_key_here \
  mailodds -- npx -y @mailodds/mcp-server

Cursor / VS Code

Open Settings, navigate to MCP (or create .cursor/mcp.json / .vscode/mcp.json), and add:

{
  "mcpServers": {
    "mailodds": {
      "command": "npx",
      "args": ["-y", "@mailodds/mcp-server"],
      "env": {
        "MAILODDS_API_KEY": "your_key_here"
      }
    }
  }
}

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "mailodds": {
      "command": "npx",
      "args": ["-y", "@mailodds/mcp-server"],
      "env": {
        "MAILODDS_API_KEY": "your_key_here"
      }
    }
  }
}

SSE Transport for Hosted Agents

For web-based or custom agents that connect over the network, use the SSE transport with Docker:

FROM node:20-alpine
WORKDIR /app
COPY index.js .
ENV MAILODDS_MCP_TRANSPORT=sse
ENV MAILODDS_MCP_PORT=3741
ENV MAILODDS_MCP_SSE_BIND=0.0.0.0
EXPOSE 3741
CMD ["node", "index.js"]

Set MAILODDS_API_KEY and MAILODDS_MCP_SSE_TOKEN at runtime via docker run -e. The SSE token protects the endpoint with Bearer authentication.

Verification

After installation, ask your AI agent: "List my MailOdds sending domains and tell me their identity grades." If it returns your domains and scores, you are connected.

Real-World Use Cases

The value of MCP becomes clear when you see how agents chain multiple tools into complete workflows. Here are four scenarios that demonstrate the difference between manual API integration and agent-driven automation.

1. DNS Remediation: From Grade C to Grade A

A developer asks their AI agent: "My emails to Gmail are bouncing. Check my sending domains and give me the exact DNS records I need to add."

The agent calls onboarding_probe to get the full account snapshot. It finds a domain with grade C and a missing DMARC record. It then calls remediate_domain, which returns the exact TXT record to add, including the host, value, and TTL. The developer copies the record into their DNS provider. The agent can verify the fix by calling get_identity_score after DNS propagation. Read the email authentication guide for a full walkthrough of SPF, DKIM, and DMARC setup.

2. Bulk Validation with Auto-Suppress

A marketing team needs to clean a 50,000-row import before a campaign. The agent calls validate_and_watch with auto_suppress_high_risk: true. It streams progress notifications every 4 seconds as the job runs. On completion, it reports: 42,100 valid, 5,200 invalid, 2,700 do-not-mail. The auto-suppress feature automatically creates a domain blocklist policy for the top toxic domains (those with 3 or more invalid or disposable addresses). If a blocklist policy already exists from a previous job, new domains are merged in. The full pipeline is documented at bulk email validation and email validation policies.

3. Safe Sending: Validate, Summarize, Deliver

A transactional system needs to send an order confirmation. The agent calls safe_deliver with validate_first: true. The tool first validates the recipient address. If the address is invalid or high-risk, delivery is blocked and the agent reports the reason. If valid, the tool auto-generates an AI summary from the HTML content and sends the message with DKIM dual signatures (RSA + Ed25519). The agent returns the message ID, delivery status, and validation result in a single response. See the email sending API and transactional email documentation.

4. Guardian Mode: Always-On Reputation Monitoring

An operations team wants continuous monitoring of their sender reputation. The agent calls subscribe_guardian with thresholds: reject rate above 5%, deliverable rate below 90%, and minimum domain grade B. Guardian starts polling telemetry and domain health every 60 seconds. When the reject rate spikes to 12% due to a bad list import, Guardian emits a notifications/guardian alert. The agent can then automatically call suppression_audit to identify the source and add_suppression to block the offending addresses. Guardian integrates with sender reputation and email analytics for a complete monitoring stack.

MCP vs. Traditional API Integration

The fastest way to understand the value of MCP is to compare it with a traditional REST API integration for the same workflow.

For straightforward single-endpoint integrations, a traditional REST API call with one of the 11 SDKs may be simpler. MCP shines when the workflow involves multiple tools, conditional logic, or ongoing monitoring. An agent that needs to diagnose a deliverability problem will call 5 to 10 tools in sequence: probe, remediate, validate, suppress, send, monitor. With MCP, that entire sequence is a single natural-language prompt.

Architecture and Security

The MCP server sits between the AI agent and the MailOdds API. Every tool call translates to one or more HTTPS requests to api.mailodds.com/v1 with Bearer token authentication.

AI Agent (Claude / Cursor / custom)
    |  JSON-RPC 2.0
    |  stdio  ----------------+
    |  SSE  ------------------+
    v                         v
@mailodds/mcp-server  (Node.js, zero deps)
    |  HTTPS + Bearer token
    v
api.mailodds.com/v1

Security is built into the design at every layer:

• API key isolation: The key is read from the MAILODDS_API_KEY environment variable only. It is never hardcoded, never logged, and never included in tool responses.
• Per-request authentication: Every HTTPS request includes a Bearer token. Keys are validated on startup and must match the mo_live_ or mo_test_ prefix format.
• SSE transport binding: SSE binds to 127.0.0.1 by default. Exposing it beyond localhost requires explicitly setting MAILODDS_MCP_SSE_BIND=0.0.0.0 and protecting the endpoint with MAILODDS_MCP_SSE_TOKEN.
• Environment safety: Destructive operations label their responses with _environment (test or live) and _profile, so agents always know which account they are operating on.
• EU-hosted, GDPR-compliant: All API traffic routes to EU infrastructure. No data leaves the European Union. Read the full security and privacy documentation, or see our GDPR email validation guide.

Frequently Asked Questions