MCP server

A connected app never gets a key. It gets an OAuth access token, issued for one team, carrying only the scopes you approved on the consent screen, and you can revoke it from Settings → Team → Authorized apps at any moment.

The scopes you approve decide which tools exist. A grant without domains:write is not a server that refuses create_domain — it is a server that does not have one.

Two scopes reach further than their names suggest, so read them before approving. emails:read can cancel a scheduled send, because cancelling only ever prevents mail. team:write can turn AI assist on, which decides whether content you ask about is sent to the AI provider. A client connected without a toolset asks for both.

These are not tools that refuse. They are tools that do not exist.

• Mint, change or revoke an API key, or manage the grants it is itself using.
• Change your plan, your billing, or who is on your team.
• Delete a domain, a template, a segment, a campaign or an automation.
• Remove a suppression — an unsubscribe stays an unsubscribe, whoever is asking.
• Regenerate a domain's DKIM keys, rotate a webhook's signing secret, or take a registrar credential.

No scope reaches them either, so there is no consent screen anywhere that could hand them over. Two deletions are tools: delete_webhook and delete_contact, which erases a person for good. Both need a write scope, and both are marked destructive, so your client asks you before each one. See Authentication for how the scopes and the API-key permissions relate.

79 tools, grouped so a client can load only the ones it needs. Every call goes through the same service the dashboard and the API use, so every rule applies unchanged. A refusal comes back as a tool result marked isError, carrying the error name the API would have answered with — so the assistant can read it and tell you which address unsubscribed, rather than reporting that something broke.

Every paged list takes limit (at most 25) and after. An html body over 4 KB is left out of what a tool returns, and a sent or received message's HTML is never returned at all.

create_webhook is the one tool that returns a secret: the endpoint's signing secret, once, because your endpoint cannot verify a delivery without it. It is your outbound secret, not a credential into Rasket. A claim started with claim_domain transfers the name by itself once its TXT record resolves, unless the current owner sent or verified recently.

Every tool says whether it only reads, whether it can overwrite, remove or send, and whether it reaches anyone outside your account. Clients use those hints to ask you before anything that changes or sends. A campaign goes out in three steps: the agent drafts it, calls preview_broadcast to show you the segment, how many subscribed contacts it holds, the subject and the sender, and only then calls send_broadcast with the confirm_token the preview returned. The token is for that draft as it stood, for one hour; an edit means a new preview.

Calling a tool this connection was not given answers with the scope it needs, or the toolset to add, so the agent can ask you for exactly that.

describe_setup needs no scope and is registered whatever the toolset filter says, so it is always the first call an agent can make. It returns the setup recipe — the same steps as the Agents guide — with each step's tool, and a plan marking which steps this connection's scopes allow and which scopes are missing. With format: "json" it returns only the plan:

{
  "steps": [
    { "id": "create_key", "title": "Create an API key", "tool": null, "scope": null, "allowed": false, "reason": "No tool creates an API key: …" },
    { "id": "add_domain", "title": "Add a domain", "tool": "create_domain", "scope": "domains:write", "allowed": true, "reason": null },
    …
    { "id": "send_broadcast", "title": "Send a broadcast", "tool": "send_broadcast", "scope": "broadcasts:write", "allowed": false, "reason": "Needs the broadcasts:write scope." }
  ],
  "missing_scopes": ["broadcasts:write", "automations:write"]
}

An agent that finds a scope missing should ask you to reconnect with it before starting, rather than stopping halfway through.

Four limits, counted per connected app, on top of your team's ten requests a second. They are deliberately low: an assistant is a person's hands, not a pipeline.

Over any of them, the call answers JSON-RPC error -32000 with a retryAfter in seconds. A refused call is not itself a tool call, so it does not hold the window open; a JSON-RPC batch is not accepted at all: it is refused with -32600 before any tool runs and costs nothing. Each accepted send, campaign and import is also written to your audit log as mcp.email_sent, mcp.broadcast_sent or mcp.contacts_imported, naming the connected app.

An assistant acts for you, so it should act the way you would. Five things keep it there, and every one of them works today.

• Your client asks first. Every tool says whether it reads, changes or sends, and Claude and ChatGPT use that to ask you before anything that changes or sends. Keep asking on for send_email and send_broadcast.
• A campaign needs your go-ahead. create_broadcast only drafts it, preview_broadcast shows you who it reaches, and send_broadcast runs only with the token that preview returned. You can still cancel_broadcast a scheduled one.
• Ask only for the scopes you need. Without a toolset, a client asks you to approve every scope its tools use. With one, it asks only for that toolset's scopes, and a tool whose scope you did not approve does not exist for that connection.
• Load only the toolsets you need. Connect with ?toolset=setup,send and the audience and marketing tools are not there at all.
• Everything is on the record. Every call is in your Logs, the budgets above cap a busy assistant, and you can revoke the app from Settings → Team → Authorized apps at any moment.

The server is at https://api.rasket.com/mcp. Every client signs in the same way: it opens a browser, you sign in to Rasket, pick the team and approve the scopes. No API key is involved. Rasket for Claude shows what to ask for once you are connected.

claude mcp add --transport http rasket https://api.rasket.com/mcp

{
  "mcpServers": {
    "rasket": {
      "type": "http",
      "url": "https://api.rasket.com/mcp"
    }
  }
}

claude mcp add --transport http rasket "https://api.rasket.com/mcp?toolset=setup,send"

The server is stateless. Each request builds a server, answers, and forgets: no session id, no stream, nothing kept between calls. GET on the endpoint is 405 — there is no stream to open — and DELETE is a 204 that does nothing, because there is no session to end.

Every tool call is logged like any other API request. It appears in your Logs with source of mcp, the tool it ran, and the connected app that ran it, so a send an assistant made is as traceable as one your own code made.