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. The hosted Outreach2day MCP server, live since September 29, 2026, covers the steps before the sequencer: domains, mailboxes and warmup. It is the default: add https://public.outreach2day.com/mcp to your AI client and sign in with your Outreach2day account. The export server built here is optional and runs locally with a key from $OUTREACH2DAY_API_KEY.

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 warmup 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, and the settings inside each sequencer are in the Instantly and Smartlead integration docs. 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["OUTREACH2DAY_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 warmup 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.

Warmup 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. Our hosted Outreach2day MCP server covers domains, mailboxes, warmup and campaigns, and exports warm mailboxes to Instantly or Smartlead after you confirm; it is live (Outreach2day MCP).

Tool-by-tool comparisons with our server, from each vendor's docs: Instantly MCP vs Outreach2day MCP and Smartlead MCP vs Outreach2day MCP. The campaign side of our server, with limits, is on cold email campaigns over MCP.

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 warmup to the sequencer?

No. Export adds the mailbox as a sending account; warmup 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.

Connect the Hosted Outreach2day Server

Add https://public.outreach2day.com/mcp to your AI client and sign in with your Outreach2day account when it asks: in claude.ai and Claude Desktop as a custom connector, in ChatGPT as a developer-mode app, in Cursor and VS Code with the one-click links on the MCP page. To set up every MCP client on your computer at once, run the installer:

curl -fsSL https://outreach2day.com/install | sh

On Windows, in PowerShell: irm https://outreach2day.com/install.ps1 | iex. The installer finds Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Gemini CLI and Codex on your computer, backs up each config file and adds an outreach2day server by URL next to the servers you already have (for Claude Desktop, which takes remote servers as connectors, it prints the steps). It asks for no API key: each client opens an Outreach2day sign-in page the first time it connects. For CI or a machine without a browser, run the installer with --use-key: it asks for the key once and the client config reads it from $OUTREACH2DAY_API_KEY. --client cursor limits it to one client, --dry-run shows the changes without writing them, --uninstall takes them out again.

Then ask your agent: "Check my Outreach2day account status". Steps for each client are on the MCP page.

Get Started

Create an account, order mailboxes in the app and connect your sequencer, then add the MCP server to your AI client and sign in. For the local server above, create a key on the API keys page.