Managing Lettr from your AI assistant

Lettr has an MCP integration which lets an AI assistant call the Lettr API on your behalf. Ask it in plain language to list last week's bounces, add a sending domain, or send a test, and it picks the right API call and returns the result in the same window. It works in whatever assistant is already open, whether Claude, ChatGPT, Cursor, or Copilot, so the same chat that drafts an email can send the test version of it without a context switch in between.

What is MCP?

MCP (Model Context Protocol) is an open standard that lets AI assistants call external services. Without it, an assistant only sees what's in the conversation (pasted text, open files, prior turns). With it, the assistant can reach a real API and act on real data, so "show me my sending domains" returns the actual list from the account.

An MCP server advertises a list of named tools (functions with typed parameters and a description). The assistant reads the list, picks the one that matches the request, fills in the arguments, and surfaces the response, with the raw JSON hidden unless asked for.

What it looks like in practice

The requests that come up most while debugging deliverability or setting things up each map to a tool. Asked in plain language, the assistant picks the matching call and returns real data from the account:

• Why did an email not arrive? The assistant lists recent bounce events for the address and shows whether it was a hard bounce, a deferral, or just a slow accept.
• Why has an address stopped receiving anything? It returns the suppression status and the reason, and can lift the suppression once the original complaint turns out to have been a mistake.
• Add a sending domain. It registers the domain and hands back the DNS records to add, then verifies the domain once DNS has propagated.
• Create and test a template. It creates a template with a set of merge tags and sends a test render to a real address, all in one request.

Each request is a plain-language description of the goal, with the assistant translating it into the matching endpoint and arguments. And because the chat keeps the prior calls in context, follow-ups are cheap: after a list of bounce events, a question like "which of these were over quota?" filters the results the assistant already retrieved instead of querying the API again.

Remote vs. local server

Lettr ships two MCP servers because chat and editor have different threat models. A chat conversation might be stored, replayed, or shared, so the remote server uses OAuth and keeps write access narrow. A code editor runs locally, so the local server can hold a real API key and expose the full API. Which to reach for depends on where the work is happening.

The rough rule is the remote server from chat tools and the local server from an editor, and both can connect to the same account at once. With the remote server, OAuth hands the tool a scoped token and no secret ever reaches the transcript. With the local server, the key sits in an env var or config file alongside every other service's credentials and never leaves the machine, which is what lets it safely expose create, delete, and webhook inspection.

The remote server is intentionally read-only. Domain changes are infrastructure decisions, and a chat thread that might be stored or shared is the wrong place for them. Both servers also honor existing Lettr permissions: an account that can't see a team's domains in the dashboard can't see them through MCP either.

Setup

Connecting takes a few minutes, and the steps differ by server. New to Lettr? Sign up first (setup is free); the integration works best once the account has two things in place:

• A sending domain to send from.
• An API key so the tools have something to act on.

From there, pick the server that matches the tool in use.

1. Remote server (Claude.ai, ChatGPT, GitHub Copilot, Cursor, Claude Desktop):

• Add https://app.lettr.com/mcp as a remote MCP server in the tool's settings.
• Complete OAuth and approve the connection.
• Tools are available immediately.

2. Local server (Claude Code, Cursor, Claude Desktop):

• Add the snippet below to .mcp.json (Claude Code) or .cursor/mcp.json (Cursor).

{
  "mcpServers": {
    "lettr": {
      "command": "npx",
      "args": ["-y", "lettr-mcp"],
      "env": {
        "LETTR_API_KEY": "lttr_your_api_key_here"
      }
    }
  }
}

• Start the assistant. lettr-mcp is fetched on the first run.

Per-client setup details for every supported AI tool live in the MCP docs.

FAQ

Bottom line

The dashboard stays the better tool for some work. Analytics charts, suppression management, and anything with a complex filter UI belong there, as does any task that needs eyes on a lot of data at once, where scrolling and sorting beat a series of follow-up questions.

MCP is good at the smaller stuff: the lookups and one-off actions that happen dozens of times during a working session and aren't worth opening another tab for. Status checks ("did the password reset to that address actually leave?"), debugging helpers ("why was this transmission rejected?"), and the kind of mid-task setup that would otherwise interrupt the work in the editor.

The sweet spot is the dozens of small interactions in a working day. Set it up in whatever assistant is already open, keep the dashboard a click away for the heavy lifting, and most of the context switching disappears. Learn more about Lettr's MCP integration, or create a free Lettr account to connect it.