MCP Server

The ReallyQuickEmails MCP server exposes your project through the Model Context Protocol. Connect it to claude.ai, Claude Desktop, Cursor or Claude Code and your assistant can query your contacts, campaigns, metrics and automations, answering in natural language.

Your assistant can query data, modify contacts and segments, create draft campaigns (which you review and send from the app), enroll contacts into automations, and even send email — each capability behind its own permission, granted by you when creating the key. Building complete automations by chat is coming soon.

The connection is secure by design:

The server holds no database credentials. It authenticates each call with your MCP key and forwards it to the API; the project is resolved from the key, never from what the assistant asks for. A key from one project cannot read another.
Each key carries its own permissions. The assistant only sees, and can only use, the tools its permissions enable.
You can revoke it any time and access is cut on the next call.

From claude.ai (fastest)

On claude.ai you don’t need to create a key by hand or edit any config file:

Add the connector

Open Settings → Connectors → Add custom connector and paste the URL:

https://mcp.reallyquickemails.com/mcp

Authorize

Claude takes you to a ReallyQuickEmails screen. Sign in if you weren’t already, pick the project you want to connect, check whether you also want to allow creating and editing, and click Authorize.That’s it: the app issues the key for you and the connector is ready.

The issued key shows up under Integrations → API Keys → MCP Keys, named after the client you connected. To disconnect the connector, revoke it there.

This path never grants sends:execute (sending real email). If you want your assistant to send on your behalf, create the key by hand with that permission and connect using the method below.

With a key (Claude Desktop, Cursor, Claude Code)

Clients that accept headers in their config use your MCP key directly.

Create an MCP key

Open the dashboard and select your project.
In the sidebar go to Integrations → API Keys.
Scroll to the MCP Keys section and click Create key.
Give it a name and check the permissions you want to grant (see Permissions). Grant only what the assistant needs.
Copy the key (rqe_mcp_...).

The full key is shown only once. If you lose it, revoke it and create a new one. Never paste it into client-side code or repositories.

REST API keys (sk_proj_...) do not work on the MCP — they return 401. The MCP uses its own key type (rqe_mcp_...), with granular permissions, created in this same section.

Connect your AI client

Use the endpoint https://mcp.reallyquickemails.com/mcp with your key in the X-API-Key header.

Claude Desktop
Cursor
Claude Code

Open Settings → Developer → Edit Config and add your server. You can also edit claude_desktop_config.json directly:

{
  "mcpServers": {
    "reallyquickemails": {
      "url": "https://mcp.reallyquickemails.com/mcp",
      "headers": { "X-API-Key": "rqe_mcp_your_key" }
    }
  }
}

Restart Claude Desktop. The server shows up in the tools picker.

Edit ~/.cursor/mcp.json (global) or .cursor/mcp.json (per project):

{
  "mcpServers": {
    "reallyquickemails": {
      "url": "https://mcp.reallyquickemails.com/mcp",
      "headers": { "X-API-Key": "rqe_mcp_your_key" }
    }
  }
}

Enable it under Settings → MCP.

Add it with one command:

claude mcp add reallyquickemails \
  --transport http \
  https://mcp.reallyquickemails.com/mcp \
  --header "X-API-Key: rqe_mcp_your_key"

Verify with claude mcp list.

Verify the connection

Ask your assistant something simple, for example:

Which ReallyQuickEmails project am I connected to?

It will call the whoami tool and answer with your project name and the key’s permissions. If you see an authorization error instead, check that you copied the full key and that it is not revoked.

To see everything your assistant can do with this key — including what it’s missing and how to enable it — ask it to call get_capabilities (see Capabilities and guided workflows).

Permissions

Each key grants one or more permissions. The assistant does not see the tools it wasn’t authorized for, and if it tries to use them anyway, the call is rejected.

Permission	Enables
`contacts:read`	Contacts, their activity, events, senders, domains and the suppression list
`contacts:write`	Create/update contacts, tags, attributes, events and suppression
`campaigns:read`	Campaigns and their metric reports
`campaigns:write`	Create campaigns as drafts (never sends them) and cancel one that is sending or scheduled
`reports:read`	Aggregated project metrics over a date range
`segments:read`	Segments and their rules
`segments:write`	Create segments
`templates:read`	Templates (metadata, not the email body)
`templates:write`	Create and edit email templates from HTML
`automations:read`	Automations and their reports
`automations:write`	Enroll contacts into active automations, and pause/resume one
`sends:execute`	Send real email (test copies included). The most sensitive permission — grant it only if you want the assistant to send on your behalf

Start with the minimum. If you only want the assistant to analyze campaign performance, campaigns:read and reports:read are enough. Grant write permissions (:write) only if you want the assistant to modify your data.

Write permissions modify your real data. Only sends:execute sends email directly, but keep in mind that adding a tag, tracking an event or enrolling into an active automation can result in a send if you have flows configured with those triggers. Grant them intentionally.

Capabilities and guided workflows

Any valid key can call get_capabilities (no permission needed, just like whoami) and gets the server’s full catalog back: every tool that exists — marking which ones are available for your key and, if not, how to enable them —, what each permission grants, the hard limits of the API (pagination, send_email max recipients, idempotency window), and a set of guided, step-by-step workflows for the jobs people actually ask for. The same workflows are registered as MCP prompts (prompts/list, prompts/get): a client that supports them can offer them directly, without going through a tool.

Workflow	What it guides
`launch_email_campaign`	Design, test and launch a campaign to an existing audience, with human approval before it sends
`import_design_and_send`	Turn an already-designed HTML email into a sent campaign
`set_up_domain`	Authenticate a sending domain so campaigns land in the inbox
`improve_deliverability`	Diagnose why delivery, opens or clicks are low, and fix what can be fixed from chat
`automate`	Audit an automation, enroll a contact into it, or troubleshoot why it didn’t fire
`report_issue`	Escalate a broken flow to a human with the context needed to act on it

For a task you don’t know well, have your assistant call get_capabilities before whoami — it’s cheaper than discovering a limit by trial and error.

Available tools

Every write tool accepts idempotency_key (optional, in the body or the Idempotency-Key header): the same key with the same body, within 24 hours, replays the original result instead of acting again. The same key with a different body responds 409 IDEMPOTENCY_CONFLICT — a fresh UUID per real action is enough.

Write results and single-entity reads (a campaign, template, segment or automation) include view_in_app: the direct link to that screen in the app.

Contacts — contacts:read

Tool	What it does
`list_contacts`	Lists contacts with search by email or name
`get_contact`	A single contact by its UUID, with its data and segments
`get_contact_activity`	What happened to a contact: emails received and events
`list_events`	Custom events tracked for the project
`get_suppression_list`	Suppressed addresses that will not receive email
`list_senders`	Verified sender identities of the project
`list_domains`	Sending domains and their authentication status

Campaigns — campaigns:read

Tool	What it does
`list_campaigns`	Campaigns with their status and counters
`get_campaign_report`	Metrics of one campaign: sent, delivered, opens, clicks, bounces

Metrics, segments, templates and automations

Tool	Permission	What it does
`get_metrics`	`reports:read`	Aggregated project metrics over a range
`list_segments`	`segments:read`	Segments with their size and rule
`list_templates`	`templates:read`	Project templates (metadata)
`get_template`	`templates:read`	One template WITH its content: final HTML and editable source — to verify subject, preheader, links and body against the database
`list_automations`	`automations:read`	Automations with their status and real trigger
`get_automation`	`automations:read`	One automation WITH its node graph and connections — to audit a flow before activating it
`get_automation_report`	`automations:read`	Performance of one automation: sent, opened, clicked
`get_automation_runs`	`automations:read`	The runs of one automation: who it fired for, when and how it ended

Diagnostics — integrations:read

To answer “why didn’t my flow trigger?” without waiting for support.

Tool	What it does
`get_shopify_integration_status`	Health of the Shopify integration: subscribed vs expected webhooks, events received, rejected deliveries
`list_checkout_events`	Shopify checkouts that reached the platform, with their processing state
`diagnose_automation`	Walks the full abandoned-cart chain and names the first broken link

Writing — contacts:write / segments:write / templates:write / campaigns:write / automations:write

These modify real data. None of them send email directly, but the ones marked can trigger active automations that do send.

Tool	Permission	What it does
`upsert_contacts`	`contacts:write`	Creates or updates up to 1000 contacts by email, with attributes and segments. May trigger new-contact flows
`add_tags`	`contacts:write`	Adds tags to an existing contact (merged, no duplicates). May trigger tag-based flows
`set_attributes`	`contacts:write`	Adds or updates attributes on an existing contact (the rest are kept)
`track_event`	`contacts:write`	Tracks a custom event (purchase, signup…). May trigger event-based flows
`suppress_email`	`contacts:write`	Adds addresses to the suppression list (they stop receiving email)
`create_segment`	`segments:write`	Creates an empty segment; you fill it from the app afterwards
`create_template`	`templates:write`	Creates an email template from HTML and returns the link to open it in the editor. Images must be public URLs
`update_template`	`templates:write`	Edits an existing template in place, keeping its id — any campaign already using it goes out with the new content. HTML, subject and/or name can be changed
`generate_template`	`templates:write`	The design engine writes a complete email from a brief, using the project’s brand identity, and saves it as a template. Takes 30-90 seconds and counts against the project’s daily AI limit
`edit_template_with_ai`	`templates:write`	Rewrites an existing template following a plain-language instruction, keeping its id. Only for templates with an editable design (ones imported as raw HTML use `update_template`)
`create_campaign`	`campaigns:write`	Creates a campaign always as a draft — you review, complete and send it from the app
`cancel_campaign`	`campaigns:write`	Stops a campaign that is sending or scheduled before it finishes. Never sends anything — it only halts
`enroll_in_automation`	`automations:write`	Enrolls a contact into an active automation — the flow runs immediately and may email them
`pause_automation`	`automations:write`	Pauses an active automation: it stops enrolling new contacts; runs already in progress finish their remaining steps
`resume_automation`	`automations:write`	Resumes a paused automation

Sending — sends:execute

Tool	What it does
`send_email`	Sends a real email immediately (up to 50 recipients), from a verified sender of the project
`send_campaign_test`	Sends one real test copy of a campaign to a single address — the same subject, template and sender the real send will use, none of the audience or metrics effects of a launch. Recommended before `send_campaign`
`send_campaign`	Launches a draft campaign to its whole audience, now or at a future time, in two steps: the first call sends nothing and returns a summary (subject, sender, template and exactly how many contacts will get the email, or what is still missing); only with `confirm: true`, after you approve that summary, does it send through the same path as the app. With `scheduled_at` (ISO 8601, up to 90 days out) it schedules the send instead of launching right away — stop it with `cancel_campaign` before it fires

All three support idempotency_key: the same key within 24h returns the previous result instead of sending again.

send_email, send_campaign_test and send_campaign (with confirm: true) send real email and cannot be undone once delivered. A campaign scheduled with scheduled_at CAN be stopped with cancel_campaign before it fires. Grant sends:execute only to keys whose assistant should send on your behalf, and revoke it when no longer needed.

Identity and utilities — no permission

Tool	What it does
`whoami`	The project the key belongs to and its permissions. Any valid key can call it
`get_capabilities`	The server’s full catalog: tools, permissions, limits and guided workflows
`get_usage`	The project’s sending quota: plan, limit, used, remaining, and whether sending is currently blocked (and why)
`send_flare`	Escalates a broken flow to a human: the user’s goal, what happened, and the chain of calls that led there. Returns a `flare_id`

Errors

Every non-2xx response has the same shape:

{
  "code": "CAMPAIGN_INCOMPLETE",
  "error": "Campaign is not ready for a test send. Missing: template_id.",
  "suggestion": "Fix everything listed in `missing` and call send_campaign_test again.",
  "request_id": "3f2a1c9e-7b44-4e21-9a2f-6c1d0a8b5e77"
}

code is stable: it decides the next step without parsing prose.
suggestion is the concrete fix — your assistant can act on it in the same turn without you stepping in.
request_id identifies that call and also travels in the X-Request-Id header of every response, success or error. Share it if you need support.

Code	When it shows up
`INVALID_INPUT`	A field failed validation — check `suggestion` (and `param`, if present) for which one
`NOT_FOUND`	The id does not exist in your project
`FORBIDDEN`	The key is missing the permission that tool needs
`UNAUTHORIZED`	The key is invalid or was revoked
`RATE_LIMITED`	Too many calls in a row — retry in a few seconds
`QUOTA_EXCEEDED`	The project hit its plan limit for the period — check `get_usage`
`IDEMPOTENCY_CONFLICT`	The same `idempotency_key` was already used with a different body
`CONFLICT`	The resource is not in a state that allows the operation
`CAMPAIGN_NOT_CANCELLABLE`	The campaign can no longer be stopped (for example, it already finished sending)
`CAMPAIGN_INCOMPLETE`	Something is missing (template, sender, subject) to send or test the campaign
`AUTOMATION_STATE`	The automation is already in the requested state (pausing one already paused, and vice versa)
`PROJECT_DISABLED`	The project cannot operate right now — contact support
`AI_QUOTA_EXCEEDED`	The project used all of its AI generations for today (resets at 00:00 UTC) — write the HTML with `create_template` or `update_template`, or retry tomorrow
`INTERNAL_ERROR`	Something failed on our side — retry, and if it persists report it with `send_flare` including the `request_id`

Partner mode (manage your client portfolio)

If you’re a partner managing several clients (each one an RQE project), you can connect the MCP with your partner key (sk_partner_...) instead of a project key. In that mode, a single connection operates at the organization level and exposes 3 tools to manage your portfolio:

Tool	What it does
`list_clients`	Lists your client projects (id, name, slug, status).
`create_client`	Creates a new client project and returns its `api_key` (`sk_proj_`) to operate it.
`get_client_stats`	30-day metrics (sent, delivered, opens, clicks) for one client.

{
  "mcpServers": {
    "reallyquickemails-partner": {
      "url": "https://mcp.reallyquickemails.com/mcp",
      "headers": { "Authorization": "Bearer sk_partner_xxxxxxxxxxxx" }
    }
  }
}

Partner mode operates per organization: list_clients/get_client_stats only see projects in your org, and create_client creates them inside it. To operate a client in detail (send, contacts, campaigns), use its project api_key with the regular MCP. Endpoint details in Partner / Provisioning.

Revoke a key

Under Integrations → API Keys → MCP Keys, click Revoke on the key. Access is cut on the next call; an assistant using it will get an authorization error. The revoked key stays listed for your records and cannot be reactivated.

FAQ

How is this different from my regular API Key?

Your API Key (sk_...) gives full access to the API, including sending email, and is meant for your own backend. The MCP key (rqe_mcp_...) has granular permissions and is meant to connect a third-party AI assistant with exactly the access you decide. Never paste your sk_... into an AI client.

Can the assistant send email or delete data?

It can send email only if you granted sends:execute — without that permission it does not even see the sending tools. Campaigns it creates are always drafts; you send them from the app or, if you granted sends:execute, with send_campaign (which first shows you the summary, can be scheduled with scheduled_at, and waits for your approval) — send_campaign_test sends a test copy before launching, and cancel_campaign stops one that is already sending or scheduled. It does not delete contacts or data: there are no delete tools. Each capability is a separate permission you grant explicitly when creating the key.

Can it build complete automations (flows)?

Not yet — that is coming soon. Today it can enroll contacts into automations you already built (with automations:write), pause and resume them, and check their performance, but designing the flow itself (nodes, triggers, conditions) happens in the app.

What if my assistant gets stuck or something doesn't work?

It can call send_flare (no permission needed, any key) to report it with full context: what you were trying to do, what happened, and the chain of calls that led there. It returns a flare_id — hand that to support if you need follow-up.

Can I have multiple keys?

Yes. One key per client or per use, each with the minimum permissions, is good practice so you can revoke one without affecting the rest.

Why won't claude.ai let me paste the key?

Because it doesn’t need one. claude.ai connectors have no field for headers: they connect over OAuth, so instead of asking for a key they take you to a ReallyQuickEmails screen where you pick the project and permissions, and the app issues the key for you. It’s the same key type (rqe_mcp_...), listed and revoked in the same place.

Guides

The app

Concepts

API Reference

From claude.ai (fastest)

With a key (Claude Desktop, Cursor, Claude Code)

Permissions

Capabilities and guided workflows

Available tools

Errors

Partner mode (manage your client portfolio)

Revoke a key

FAQ

​From claude.ai (fastest)

​With a key (Claude Desktop, Cursor, Claude Code)

​Permissions

​Capabilities and guided workflows

​Available tools

​Errors

​Partner mode (manage your client portfolio)

​Revoke a key

​FAQ

From claude.ai (fastest)

With a key (Claude Desktop, Cursor, Claude Code)

Permissions

Capabilities and guided workflows

Available tools

Errors

Partner mode (manage your client portfolio)

Revoke a key

FAQ