# Slack (official)

> Slack's own hosted MCP server — search, send messages, read threads, and manage canvases, gated by workspace admins.

[Canonical HTML page](https://top-mcps.com/mcp/slack-mcp-server) · [server.json](https://top-mcps.com/mcp/slack-mcp-server.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "slack-mcp-server": {
      "command": "Claude",
      "args": [
        "Code:",
        "/plugin",
        "install",
        "slack@claude-plugins-official",
        "·",
        "Cursor:",
        "/add-plugin",
        "slack",
        "·",
        "or",
        "add",
        "https://mcp.slack.com/mcp",
        "as",
        "an",
        "HTTP",
        "MCP",
        "server"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
claude mcp add slack-mcp-server -- Claude Code: /plugin install slack@claude-plugins-official · Cursor: /add-plugin slack · or add https://mcp.slack.com/mcp as an HTTP MCP server
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "slack-mcp-server": {
      "command": "Claude",
      "args": [
        "Code:",
        "/plugin",
        "install",
        "slack@claude-plugins-official",
        "·",
        "Cursor:",
        "/add-plugin",
        "slack",
        "·",
        "or",
        "add",
        "https://mcp.slack.com/mcp",
        "as",
        "an",
        "HTTP",
        "MCP",
        "server"
      ]
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "slack-mcp-server": {
      "command": "Claude",
      "args": [
        "Code:",
        "/plugin",
        "install",
        "slack@claude-plugins-official",
        "·",
        "Cursor:",
        "/add-plugin",
        "slack",
        "·",
        "or",
        "add",
        "https://mcp.slack.com/mcp",
        "as",
        "an",
        "HTTP",
        "MCP",
        "server"
      ]
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "slack-mcp-server": {
      "command": "Claude",
      "args": [
        "Code:",
        "/plugin",
        "install",
        "slack@claude-plugins-official",
        "·",
        "Cursor:",
        "/add-plugin",
        "slack",
        "·",
        "or",
        "add",
        "https://mcp.slack.com/mcp",
        "as",
        "an",
        "HTTP",
        "MCP",
        "server"
      ]
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "slack-mcp-server": {
      "command": "Claude",
      "args": [
        "Code:",
        "/plugin",
        "install",
        "slack@claude-plugins-official",
        "·",
        "Cursor:",
        "/add-plugin",
        "slack",
        "·",
        "or",
        "add",
        "https://mcp.slack.com/mcp",
        "as",
        "an",
        "HTTP",
        "MCP",
        "server"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "Claude",
          "args": [
            "Code:",
            "/plugin",
            "install",
            "slack@claude-plugins-official",
            "·",
            "Cursor:",
            "/add-plugin",
            "slack",
            "·",
            "or",
            "add",
            "https://mcp.slack.com/mcp",
            "as",
            "an",
            "HTTP",
            "MCP",
            "server"
          ]
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.slack-mcp-server]
command = "Claude"
args = [
  "Code:",
  "/plugin",
  "install",
  "slack@claude-plugins-official",
  "·",
  "Cursor:",
  "/add-plugin",
  "slack",
  "·",
  "or",
  "add",
  "https://mcp.slack.com/mcp",
  "as",
  "an",
  "HTTP",
  "MCP",
  "server",
]
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "slack-mcp-server": {
      "command": {
        "path": "Claude",
        "args": [
          "Code:",
          "/plugin",
          "install",
          "slack@claude-plugins-official",
          "·",
          "Cursor:",
          "/add-plugin",
          "slack",
          "·",
          "or",
          "add",
          "https://mcp.slack.com/mcp",
          "as",
          "an",
          "HTTP",
          "MCP",
          "server"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Settings → Connectors (remote URL)`

Paste this into Settings → Connectors → Add custom connector. Requires ChatGPT Pro / Team / Enterprise / Edu with Developer mode enabled. ChatGPT supports remote HTTPS MCP servers only — stdio servers must be hosted on a public HTTPS endpoint first.

```json
{
  "name": "Slack (official)",
  "transport": "http",
  "url": "https://mcp.slack.com/mcp"
}
```

## At a glance

- **Maintainer:** Slack
- **Transport:** Streamable HTTP
- **Auth model:** OAuth 2.1
- **Required secrets:** None
- **Supported clients:** Claude.ai, Claude Code, Cursor, Perplexity, Any remote-MCP client with OAuth
- **License:** Proprietary
- **Language:** TypeScript
- **Latest version:** remote
- **Last verified:** 2026-09-03
- **GitHub stars:** 120 (fetched 2026-09-14T10:51:07.851Z)
- **Score:** 74/100 (rubric 2026-09 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/slackapi/slack-skills-plugin
- **Homepage:** https://docs.slack.dev/ai/mcp-server/

## Security & scope

- **Access scope:** network
- **Sandbox:** Hosted endpoint at mcp.slack.com/mcp over Streamable HTTP. Authorisation is a per-user OAuth token whose scopes are enumerated per tool in Slack's docs, and the client itself must pass the workspace's app-approval process. No local process runs; the trust boundary is the approved app plus the scopes the user consented to.
- **Gotchas:**
  - chat:write, channels:write and files:write let an agent post, create channels and upload files as the authorising user. Consent only to the scopes the workflow needs; an agent that can send is one prompt away from sending the wrong thing to the wrong channel.
  - Admin approval is required and can be denied — check the workspace's app policy before promising a rollout.
  - File upload is two calls; the file is invisible until slack_complete_file_upload succeeds, so a half-finished upload leaves nothing behind but also nothing shared.
  - The linked repository is the installer plugin, not the server — the server itself is closed and hosted, so you cannot audit or self-host it.

## Quick answer

**What it does.** Exposes fifteen tools over Streamable HTTP, each mapped to specific OAuth user-token scopes: search (search:read.*), read history (channels/groups/mpim/im:history), send (chat:write), create conversations (channels/groups/im/mpim:write), reactions (reactions:write), canvases (canvases:read/write), users (users:read, users:read.email), channel members and user channels (channels/groups/im/mpim:read), Lists (lists:read/write), and file upload (files:write via slack_get_file_upload_url then slack_complete_file_upload).

**Best for:**
- Company workspaces with app-approval policies
- Searching messages, files and people from an agent
- Reading and replying in threads
- Creating and updating canvases
- Teams already on the Claude Code or Cursor Slack plugin

**Not for:**
- Workspaces whose admins block MCP clients
- Setups that need a raw bot token and no OAuth
- Self-hosted-only environments

## Description

The official Slack MCP server is Slack's first-party endpoint at mcp.slack.com/mcp. It exposes fifteen documented tools: search across messages, files, users, channels and emoji; send, draft and read messages and threads; create channels and DMs; add reactions; create, update and read canvases; look up user profiles and channel members; manage Lists; and a two-step file upload. Access is granted by OAuth and controlled through Slack's standard app-approval flow, so workspace admins decide which MCP clients may connect.

## Why it matters

It is the only Slack MCP path that runs through Slack's own approval and audit model. Every community server needs a user or bot token someone exported; this one is authorised per user through OAuth and can be approved, scoped and revoked by a workspace admin like any other Slack app. For a workspace with compliance obligations that difference is the whole decision. It is also the server behind the Slack plugins on the official Claude Code and Cursor marketplaces, and the one Claude.ai and Perplexity connect to.

## Key features

- First-party Slack server at mcp.slack.com/mcp
- Fifteen documented tools with per-tool OAuth scopes
- Admin-approved via the standard Slack app flow
- OAuth 2.0 with RFC 8414 metadata and PKCE for desktop clients
- Ships inside the official Claude Code and Cursor Slack plugins

## FAQ

### Is this different from the community Slack MCP?

Yes, and both are listed. This is Slack's own hosted server at mcp.slack.com/mcp, authorised per user through OAuth and approved by workspace admins. The community slack-mcp-server (korotovsky, 1.8k stars) is a local stdio server you run yourself with a token — no approval step, but also no admin governance.

### Does my admin have to approve it?

Yes. Slack routes MCP clients through its standard app-approval process, so a workspace admin can approve, scope and revoke each client. That is the point of this server for a company workspace, and the reason it may be blocked in one that restricts apps.

### What tools are exposed?

Slack documents fifteen by capability and scope rather than by identifier: search messages/channels, search files, read files, search emoji, search users, send message, read a channel or thread, create a conversation, add reactions, canvas create/update, user profile and email, list channel members, list user channels, Lists, and upload a file. The upload is two steps — slack_get_file_upload_url, then POST the bytes, then slack_complete_file_upload — and the file is not visible until the second step completes.

### How do I connect?

The shortest path is a marketplace plugin: /plugin install slack@claude-plugins-official in Claude Code, or /add-plugin slack in Cursor — each configures the MCP server and prompts for OAuth on first use. Claude.ai and Perplexity also offer it as a built-in connector. Any other client adds https://mcp.slack.com/mcp as an HTTP server; it publishes RFC 8414 authorization-server metadata and supports PKCE for desktop clients.

### Is the server open source?

No. The server is hosted by Slack. The linked repository is the MIT-licensed slack-skills-plugin that installs it into Claude Code and Cursor along with Slack developer skills — its .mcp.json is just the URL and an OAuth client ID. Treat the star count as interest in the plugin, not a readable server codebase.

## Changelog

- **2026-09-03** — Refreshed install snippets and fact sheet; verified for 2026.
- **2026-02-12** — Initial directory listing.