Instantly and Smartlead MCP Servers for Claude

The Instantly MCP server and the Smartlead MCP server let Claude or Cursor read campaign stats, manage leads and change campaigns in plain language. Both work mainly inside the sequencer: campaigns, leads, replies and the sending accounts already connected to it.

This post covers what each server exposes and how to connect it, based on the vendors' own documentation as of September 2026. Then it builds a small MCP server that exports your Outreach2day mailboxes into an Instantly or Smartlead account after you approve the list.

Instantly MCP Server

• URL: https://mcp.instantly.ai/mcp (HTTP).

• Auth: your Instantly API key, either in the Authorization header or appended to the URL path (/mcp/YOUR_API_KEY).

• Tools: the help center lists 31 in five groups: campaigns (6), leads (11), email (5), analytics (3) and accounts (6). The account tools cover sending accounts, including warm-up and account health.

• Price: free with an Instantly subscription.

Source: Instantly help center, "Instantly MCP" (updated August 2026). In Claude Desktop: Settings, Connectors, Add custom connector, then paste the URL with your key. In Cursor: an entry in ~/.cursor/mcp.json.

With Claude Code, an HTTP server with a header is added like this:

claude mcp add --transport http instantly \
  https://mcp.instantly.ai/mcp \
  --header "Authorization: $INSTANTLY_API_KEY"

Prefer the header over the URL form: a key in a URL ends up in logs and screenshots.

Smartlead MCP Server

• URL: https://mcp.smartlead.ai/sse?user_api_key=YOUR_API_KEY

• Transport: SSE only. The help center says HTTPS transport is not supported for now.

• Auth: the Smartlead API key from Settings, passed in the URL.

• Tools: campaign status and insights, lead data, deliverability checks and diagnostics.

Source: Smartlead help center, "Smartlead MCP Server". Its setup guide targets Claude Desktop and lists Node.js as a prerequisite. Claude Code accepts SSE servers too:

claude mcp add --transport sse smartlead \
  "https://mcp.smartlead.ai/sse?user_api_key=$SMARTLEAD_API_KEY"

What Neither Server Does

Neither server sets up mailboxes you buy from another provider. Instantly's API has done-for-you order endpoints that buy domains and accounts from Instantly itself (API reference); check the server's current tool list to see which of them your client gets. Mailboxes from elsewhere reach Instantly or Smartlead in two ways: you add them one by one with their SMTP and IMAP logins, or your mailbox provider pushes them in through the sequencer's API.

Outreach2day does the second through its sequencer endpoints: connect the Instantly or Smartlead account once with its API key, then export mailboxes in bulk or turn on auto-export for new ones. The REST version is in how to add email accounts to Instantly or Smartlead via API. The MCP server below lets Claude do the export step.

An Export Tool for Claude

The server has four tools:

Two choices are deliberate:

• No tool creates the connection. Creating it means passing your Instantly or Smartlead API key, and a key typed into a chat is stored in the conversation. Create the connection once with curl (step 3 of the export post); the key is stored encrypted and only its last four characters come back.

• Export needs an approved plan and an explicit list. Export sends each mailbox's SMTP and IMAP login to the sequencer. The API exports every eligible mailbox when mailboxAddresses is left out; the server always sends an explicit list and caps a plan at 100 mailboxes.

Save this as o2d_export_mcp.py. Setup, testing and client config are the same as in the cold email MCP server post.

import os
import uuid

import requests
from mcp.server import MCPServer
from mcp.server.mcpserver.exceptions import ToolError
from mcp.types import ToolAnnotations

BASE = "https://public.outreach2day.com"
KEY = os.environ["O2D_API_KEY"]
WS = int(os.environ["O2D_WORKSPACE_ID"])
READ = ToolAnnotations(read_only_hint=True)
PLANS = {}

mcp = MCPServer("outreach2day-export")


def call(method, path, params=None, **kwargs):
    try:
        r = requests.request(
            method, BASE + path, timeout=60,
            headers={"Authorization": f"Bearer {KEY}"},
            params={"workspaceId": WS, **(params or {})},
            **kwargs,
        )
    except requests.RequestException as e:
        raise ToolError(
            f"Network error ({type(e).__name__}); the "
            "request may have arrived. Check state "
            "before retrying.") from e
    if r.status_code >= 400:
        raise ToolError(
            f"API {r.status_code}: {r.text[:300]}")
    return r.json()


@mcp.tool(annotations=READ)
def list_sequencers() -> list:
    """Instantly/Smartlead connections of the
    workspace and whether each can export."""
    res = call("GET", "/sequencers")
    keep = ("id", "provider", "name", "status",
            "canExport", "blockingReason")
    return [{k: s.get(k) for k in keep}
            for s in res["sequencers"]]


@mcp.tool(annotations=READ)
def plan_export(connection_id: int,
                mailboxes: list[str]) -> dict:
    """Prepare adding mailboxes to a sequencer.
    Changes nothing. Export sends each mailbox's
    login to the sequencer, so show the plan and
    call apply_export_plan only after approval."""
    ready = call("GET",
                 f"/sequencers/{connection_id}/readiness")
    if not ready.get("canExport"):
        raise ToolError("Cannot export: "
                        f"{ready.get('blockingReason')}")
    rows = call("GET", "/mailboxes",
                params={"workspace_id": WS})
    asked = {m.strip().lower() for m in mailboxes}
    known = {(m["address"] or "").lower()
             for m in rows}
    found = sorted(asked & known)
    if not 0 < len(found) <= 100:
        raise ToolError("Need 1-100 known mailboxes")
    plan_id = uuid.uuid4().hex
    PLANS[plan_id] = {"connection_id": connection_id,
                      "mailboxes": found,
                      "result": None}
    return {"plan_id": plan_id,
            "connection_id": connection_id,
            "mailboxes": found,
            "not_found": sorted(asked - known)}


@mcp.tool(annotations=ToolAnnotations(
    read_only_hint=False, destructive_hint=False,
    idempotent_hint=True))
def apply_export_plan(plan_id: str) -> dict:
    """Export the mailboxes of an approved plan.
    Calling it again returns the first result."""
    plan = PLANS.get(plan_id)
    if plan is None:
        raise ToolError("Unknown plan_id; call "
                        "plan_export first")
    if plan["result"] is None:
        cid = plan["connection_id"]
        res = call(
            "POST", f"/sequencers/{cid}/export",
            json={"mailboxAddresses":
                  plan["mailboxes"]})
        if not res.get("exported") and \
                not res.get("failed"):
            raise ToolError(
                "Nothing exported: already exported, "
                "or the sequencer rejected its API "
                "key. Check export_history.")
        plan["result"] = res
    res = plan["result"]
    details = res.get("details") or []
    seen = {(d.get("email") or "").lower()
            for d in details}
    return {"exported": res.get("exported"),
            "failed": res.get("failed"),
            "errors": [d for d in details
                       if d.get("error")],
            "not_exported": sorted(
                set(plan["mailboxes"]) - seen)}


@mcp.tool(annotations=READ)
def export_history(connection_id: int) -> list:
    """Export records of a connection: mailbox_id,
    status, last_error, exported_at."""
    res = call("GET",
               f"/sequencers/{connection_id}/exports")
    keep = ("mailbox_id", "status", "last_error",
            "exported_at")
    return [{k: e.get(k) for k in keep}
            for e in res["exports"]]


if __name__ == "__main__":
    mcp.run()

plan_export checks the connection's readiness first. If canExport is false, the tool returns the blockingReason, for example API_KEY_REQUIRED for a connection saved with a login only. Addresses are compared in lower case. The API skips mailboxes already exported to the connection and mailboxes that are still being set up, deactivated or frozen; the tool lists them under not_exported. A result of 0 exported and 0 failed usually means the sequencer rejected its API key, so the tool reports it as an error instead of storing it. A second apply_export_plan with the same plan returns the stored result without calling the API.

Using Both Servers Together

Claude Code and Claude Desktop can run several MCP servers at once. With the Instantly (or Smartlead) server and this one connected, a session looks like this:

1. You: "Which mailboxes on acmemail.com are warming for 14 days or more?" Claude answers with the warm-up server.

2. You: "Export those to Client A Instantly." Claude calls list_sequencers, then plan_export, and shows the list.

3. You approve. Claude calls apply_export_plan and reports exported and failed counts.

4. You: "Add them to the Q4 campaign." Claude uses the Instantly server's own tools.

Warm-up stays in Outreach2day after export. Leave it running while the mailbox sends (see the email warmup API).

Instantly vs Smartlead MCP at a Glance

Other hosted cold email MCP servers (Salesforge, Maildoso) are listed in the cold email MCP server post, and the domain and mailbox side is in MCP for cold email infrastructure. A hosted Outreach2day MCP server is in development (Get early access on the home page).

FAQ

What is the Instantly MCP server URL?

https://mcp.instantly.ai/mcp, with your Instantly API key in the Authorization header.

Does Smartlead MCP work with Claude Code?

Yes, as an SSE server with claude mcp add --transport sse (command above). Smartlead's own guide covers Claude Desktop.

Do I need the Instantly or Smartlead MCP server to use this one?

No. The export tool works on its own. The sequencer servers add campaign and lead tools on top.

Does export move warm-up to the sequencer?

No. Export adds the mailbox as a sending account; warm-up stays in Outreach2day.

Which sequencers are supported?

Instantly and Smartlead. For other tools, the app exports a CSV with the SMTP and IMAP logins of your mailboxes.

Is export charged?

No. Sequencer sync is included on every plan; see pricing.

Can the assistant reconnect disconnected mailboxes?

The API has POST /sequencers/{connection_id}/reconnect, and autoReconnectMailboxes runs it on a schedule. Turn that flag on when you create the connection and the assistant does not need a tool for it.

Get Started

Create an account, order mailboxes in the app, create a key on the API keys page, connect your sequencer, then run the server above.

Get an API key→