Skip to content
Agentic Control Plane

The Slack MCP server control model, explained

The official Slack MCP server is first-party and hosted by Salesforce at https://mcp.slack.com/mcp. It has been generally available since February 17, 2026. You can reach it today as a Claude Code plugin, a Claude Desktop connector, and through partner clients including Perplexity and Cursor.

It replaces a messy history. Anthropic’s early reference Slack server was archived in May 2025. The same month, Slack’s API terms changed to prohibit bulk export and LLM training on API data. Community servers filled the gap. The most popular of them runs on unofficial token modes lifted from a logged-in browser session, a path Slack’s terms don’t sanction and this page doesn’t cover.

This page is the reference for the first-party server: what ships, how each mechanism behaves, and where the model ends. Primary source: the official server docs.

This page covers the server’s own controls. For the cross-server picture, see the MCP server controls comparison. For what a control layer adds on top, see the coverage matrix.

A note on scope. This page is about Slack as an MCP server: outside agents reaching into your workspace through mcp.slack.com. Slackbot’s MCP client, where Slack reaches out to other vendors’ servers, is a separate product with its own admin controls. Claims you’ll read about “per-action confirmation on writes” belong to that client, not to this server. Nothing on the server side confirms a write per action.

What’s at stake

Two things, and both differ from every other server in this series.

Sends are social and instant. The tools include sending messages as the authenticated user. A merged PR can be reverted. A sent Slack message is read by people within seconds, and deleting it doesn’t unsend what they saw. The damage from a bad write isn’t state. It’s what colleagues, customers in shared channels, and executives now believe you said. No other surface in our comparison is this irreversible this fast.

Reads are candid internal speech. History and search tools reach channel archives, private channels, group DMs, and DMs, wherever the connecting user’s memberships reach. That isn’t documentation or ticket metadata. It’s how people actually talk to each other when they aren’t being careful. An agent with search scopes across a workspace is reading the organization’s least considered writing.

Auth, admin approval, and permission mirroring

Authentication is confidential OAuth 2.0 with user tokens, with PKCE for desktop clients. The agent acts as the user who connected, not as a bot. Actions run on behalf of that user, so the agent reads what the user can read and posts where the user can post. This is the same vendor-enforced floor as GitHub’s token scope, with the same catch: for most users, that floor is most of the workspace.

Above the floor sits a real admin plane, and it works at the connection level. Every MCP client must be backed by a registered Slack app with a fixed app ID. Per the docs, workspace admins approve and manage all MCP client integrations through the standard app approval process. In a workspace that requires app approval, no MCP client reaches any user until an admin says yes, and admins can remove the app later.

This is Atlassian’s admin-plane story for messaging. The vendor’s controls answer “which apps may connect,” decided by someone who isn’t the agent.

Scopes: what gates the write tools

The user scopes granted to the backing app gate the tools, per capability:

  • Search splits by surface: search:read.public, search:read.private, search:read.im, search:read.mpim, plus search:read.files and search:read.users. This is the one place the grain admits that DMs differ from public channels.
  • Reading history: channels:history, groups:history, im:history, mpim:history. File contents need files:read.
  • Sending: chat:write. One scope covers all destinations.
  • Creating conversations: channels:write (public), groups:write (private), im:write, mpim:write.
  • The rest: reactions:write, canvases:read and canvases:write, users:read, users:read.email.

The grain is the capability class, granted once at the app. Scopes can’t say where. chat:write is one bit, and an app holding it can post to every channel and DM the user can. There is no scope for “this channel set only.” The only read-only version of a connection is withholding the write scopes from the whole app.

IP allowlists and eligibility

Two more lines that Slack enforces. If the backing app has allowed IP ranges, MCP requests face the same restriction, and calls from other IPs are rejected, as with the Web API. And eligibility is a control too: only Marketplace-published apps or internal apps may use MCP. Unlisted apps are rejected outright.

Together with the May 2025 terms (no bulk export, no training on API data), the intent is clear. Slack data reaches agents through one reviewed, revocable door that carries identity. Rate limits apply too, using the same per-tool Web API tiers. They stop abuse. They don’t tell a legitimate send from a regrettable one.

Audit: per-call, named, Enterprise-gated

Slack earns credit here that most servers don’t. The Audit Logs API actions reference has a dedicated Slack MCP Server section with eleven actions. Each is a per-invocation event: mcp_slack_send_message_tool_called, mcp_slack_read_channel_tool_called, mcp_slack_read_thread_tool_called, mcp_slack_search_public_and_private_tool_called, canvas create, read, and update, user-profile reads, and the rest. Each is described as an AI app acting “on behalf of a user in your organization.”

That puts Slack among the three servers in this series, with Atlassian and Zapier, that keep a per-call, admin-queryable record.

The limits follow the audit gap:

  • The Audit Logs API is an Enterprise Grid feature, so most workspaces never see these events.
  • The entries name the action and the acting user, not the message text or arguments. mcp_slack_send_message_tool_called tells you a send happened, not what it said or to whom.
  • It’s a record, not a rule. It’s written after the call, and nothing consults it before one.

That last limit bites hardest here, because by the time the log line exists, people have already read the message.

What’s missing

  • No approvals, no drafts. Nothing native holds a send for a human. The admin approved the connection. After that, every message the agent sends is as unguarded as the user typing it, on the one surface in this series where a write can’t be recalled.
  • No per-agent channel allowlist. chat:write is workspace-wide within the user’s reach. “This agent may post only in #agent-output” can’t be expressed.
  • No velocity control. Rate tiers are abuse limits, not policy. Twenty messages a minute to twenty channels is within bounds.
  • No per-call policy. Every control above decides which app connects with which capability classes. An approved app, in scope, on an allowed IP, can make any call those grants cover. On Enterprise Grid, the log will record that it did.

Where the native model ends

Slack built strong walls around the connection (approval, eligibility, scopes, IP, revocation) and a real per-call record behind it. It left nothing between an approved agent’s decision to send and a person reading the result. A ten-second pause is often the difference between an incident and a non-event on this surface, and no native mechanism can buy it.

What to do now:

  • Keep app approval required and deliberate.
  • Grant write scopes only to apps whose agents must post, and keep search-scoped and send-scoped apps separate.
  • Turn on IP allowlists for headless clients.
  • On Enterprise Grid, watch the mcp_slack_*_tool_called events.

Then add what no vendor ships: a hold on send_message, a per-minute call ceiling, and a record of each send with the agent that made it, in a layer outside the Slack app config. ACP does this with a hook in your agent’s harness that sends each tool call to a gateway. It decides per tool call, so it can’t limit sends to one channel, because it doesn’t match on arguments. The hook is harness configuration, so pin it with managed settings on machines you don’t trust.

Across the sixteen first-party MCP servers in this series, one has a native per-call approval: AWS’s fail-closed consent prompt, which its own vendor’s managed successor deprecates. Three keep per-call audit trails: Atlassian’s, this one, and Zapier’s. All three live in vendor consoles, and none is consulted before a call. Every other strong control is either vendor-side credential scoping or an admin plane over connections. Nobody checks each call as it happens, and that is still an open seat.

Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  Getting started