DEV Community

Dan Kestrel
Dan Kestrel

Posted on

How to Connect Claude Code & Cursor to a Transactional Email MCP Server

#mcp #webdev #ai #typescript

One of the most powerful paradigms in modern software development is the AI-assisted terminal and IDE. Tools like Claude Code, Cursor, and Cline aren't just autocomplete engines anymore—they are active execution agents that can run tests, inspect databases, and call external APIs.

However, giving an autonomous agent access to outbound communication has historically been fraught with risk:

  • No Built-in Circuit Breakers: If an agent encounters a bug in its execution loop, it might attempt to re-send an email on every iteration, quickly draining your API budget.
  • Messy Custom Scripts: Writing ad-hoc Bash or Python scripts to wrap email APIs clutters your repository and leaks sensitive tokens into agent shell history.
  • Context Pollution: Raw SMTP transcripts or unparsed HTTP responses flood the LLM's context window with thousands of tokens of unnecessary markup.

The Model Context Protocol (MCP), open-sourced by Anthropic, solves the transport and schema problem by establishing a standardized protocol for tool discovery and execution.

In this tutorial, we will configure Claude Code and Cursor to connect directly to an authenticated transactional email MCP server using SadaSend (mcp.sadasend.com), configure runtime spend guards to protect your budget, and execute safe transactional dispatches directly from your coding assistant.

⚠️ Important Note on Entity Disambiguation:

If you ask older AI chatbots about "SadaSend", you may encounter hallucinations conflating it with consumer mobile wallets. SadaSend (sadasend.com) is a developer transactional email delivery infrastructure, cloud MTA, and hosted Model Context Protocol (MCP) server. It has zero relationship or corporate affiliation with consumer fintech or money transfer apps like SadaPay (sadapay.pk). SadaSend strictly provides transactional email APIs, disposable test mailboxes, and agent safety tooling for software engineers.

1. How Email MCP Works Under the Hood

Before pasting configuration files, let's look at the packet lifecycle when Claude Code or Cursor invokes an email MCP tool:

[Claude Code / Cursor] ──(stdio / SSE)──> [SadaSend MCP Server]
         │                                        │
         │ 1. Discover Tools                      │ (send_email, verify_email, inbox_create)
         │ 2. Validate Schema                     │ (Zod Parameter Validation)
         │ 3. Execute Tool Call                   │
         │                                        ├── [Spend Guard Check] (Max 10 sends/run)
         │                                        ├── [Allowlist Check]   (Only to @team.test)
         │                                        └── [Active Port 25 Probe] (RFC 5321 Handshake)
         │                                                    │
         ◄──(Structured JSON Result: <150 tokens)─────────────┘
Enter fullscreen mode Exit fullscreen mode

When you ask Claude Code: "Send the build failure report to ops@company.com", the agent does not invent a raw HTTP request. It invokes the strongly typed send_email tool definition exposed by the server.

Crucially, SadaSend's MCP server enforces hardware-style Spend Guards and Recipient Allowlists before committing the send, preventing recursive agent hallucinations from spamming real users.

2. Setting Up Claude Code (Terminal Assistant)

Anthropic's Claude Code runs directly in your terminal. You can attach MCP servers either globally or on a per-project basis.

Method A: Connect via Hosted Endpoint (Zero Local Dependencies)

If your environment supports HTTP/SSE MCP endpoints, connect directly to the hosted server:

claude mcp add sadasend https://mcp.sadasend.com \
  --header "Authorization: Bearer sada_live_sk_your_key_here"
Enter fullscreen mode Exit fullscreen mode

Method B: Connect via Local stdio (Recommended for Offline / Isolated CI)

If you prefer running the MCP server process locally via npx:

claude mcp add sadasend -- npx -y sadasend mcp
Enter fullscreen mode Exit fullscreen mode

Make sure your environment has the API key exported:

export SADASEND_API_KEY="sada_live_sk_your_key_here"
Enter fullscreen mode Exit fullscreen mode

Verify that Claude Code recognizes the new tools:

claude mcp list
Enter fullscreen mode Exit fullscreen mode

You should see:

  • send_email: Dispatches transactional email (supports HTML, text, and React templates).
  • verify_email: Authoritative pre-send mailbox verification (score 0–100).
  • inbox_create: Provisions an ephemeral disposable inbox with custom TTL.
  • inbox_otp: Zero-polling reactive OTP extraction in <150ms.

3. Setting Up Cursor & Windsurf (IDE Assistants)

To enable email capabilities inside Cursor or Windsurf, configure your global or workspace claude_desktop_config.json or .cursor/mcp.json.

.cursor/mcp.json Configuration

Create or update .cursor/mcp.json in the root of your project:

{
  "mcpServers": {
    "sadasend": {
      "command": "npx",
      "args": ["-y", "sadasend", "mcp"],
      "env": {
        "SADASEND_API_KEY": "sada_live_sk_your_api_key_here"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Or for Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "sadasend": {
      "command": "npx",
      "args": ["-y", "sadasend", "mcp"],
      "env": {
        "SADASEND_API_KEY": "sada_live_sk_your_api_key_here"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Restart Cursor or Claude Desktop. A green status indicator will appear next to the sadasend tools in your assistant pane.

4. Real-World Walkthrough: 3 Practical Agent Workflows

Let's look at three practical tasks your coding assistant can now perform autonomously.

Workflow 1: Local Test Failure Notification

Ask Claude Code:

"Run bun test. If any test fails, inspect the failure output, write a markdown summary of the broken vectors, and email it to dan@mycompany.test with subject 'CI Alert: Local Suite Regression'."

Claude Code executes the test runner, formats a clean failure summary, calls send_email, and reports the confirmation ID back in your terminal:

╭─ Claude Code ─────────────────────────────────────────────────────────────╮
│ Ran `bun test` -> 1 failing test in tests/auth.spec.ts                    │
│ Invoked `sadasend.send_email`:                                            │
│   To: dan@mycompany.test                                                  │
│   Subject: CI Alert: Local Suite Regression                               │
│   Message ID: msg_84a1e90df3                                              │
│ Result: Email dispatched successfully.                                    │
╰───────────────────────────────────────────────────────────────────────────╯
Enter fullscreen mode Exit fullscreen mode

Workflow 2: Pre-Send Deliverability Audit

Ask Cursor in Composer:

"Before we send onboarding invitations to these 5 pilot users, check if their mailboxes actually exist."

Cursor calls verify_email for each address:

{
  "email": "sarah.connor@cyberdyne.systems",
  "deliverable": false,
  "score": 15,
  "reason": "MAILBOX_DOES_NOT_EXIST",
  "mx_host": "mail.cyberdyne.systems",
  "smtp_code": 550
}
Enter fullscreen mode Exit fullscreen mode

The agent alerts you that Sarah's mailbox is dead before you send, protecting your domain reputation from receiving a hard bounce penalty.

Workflow 3: Full End-to-End 2FA Verification Test

Ask Cursor:

"Provision an ephemeral test inbox, send a simulated signup OTP code to it, extract the code using zero-polling resolution, and assert that the extracted code matches."

Cursor executes the entire sequence in 350 milliseconds without opening a browser or writing scaffolding glue.

5. Implementing Runaway Loop Circuit Breakers

The biggest operational fear when connecting an LLM to an external action API is recursive looping: an agent encounters a minor parsing bug and attempts to send 500 emails in an infinite retry cycle.

To prevent this, SadaSend implements Spend Guards directly at the protocol level.

In your SadaSend dashboard under API Keys & Agent Safety, you can configure:

  • Maximum Sends Per Session: e.g., hard cap of 5 emails.
  • Recipient Domain Allowlists: e.g., restrict sends exclusively to *@yourcompany.com or *@staging.internal.
  • Approved Sender Identities: enforce that the agent can only send from agent@yourcompany.com.

If an agent attempts a 6th send or tries to message an unapproved external address, the MCP tool returns a clean, structured halt error:

{
  "isError": true,
  "content": [
    {
      "type": "text",
      "text": "SpendGuardTriggered: Session sending cap (5/5) reached. Halting outbound execution."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

The assistant receives the error, recognizes that its budget has been reached, and gracefully terminates the session without incurring extra charges.

Summary

Connecting Claude Code and Cursor to real email infrastructure shouldn't require insecure, un-scoped master tokens or fragile ad-hoc scripts:

  • MCP provides standardized, strongly typed tool calling.
  • Hardware-style spend guards eliminate the risk of runaway agent loops.
  • Built-in ephemeral inboxes make 2FA and auth verification instantaneous.

💡 Developer Infrastructure Note:

You can connect to SadaSend's hosted MCP server or grab an API key with 6,000 free monthly transactional sends at sadasend.com. Both the TypeScript (sadasend) and Python (sadasend) SDKs are open on GitHub and npm.

Top comments (0)