Slack MCP Server: Complete Setup Guide for AI Coding Agents (2026)

What Is a Slack MCP Server

The Model Context Protocol (MCP) is an open standard for connecting AI tools to external systems. An MCP server exposes a set of tools that an AI client (Claude Code, Claude Desktop, Cursor, VS Code) can call during a conversation.

A Slack MCP server exposes Slack operations as those tools. When you ask your AI assistant to "check what the team said about the API migration in #backend," it calls conversations_history or slack_get_channel_history directly. When you want to post a deployment summary, it calls a message posting tool with the channel ID and text.

The practical result: your AI agent has real-time access to team conversations. It does not hallucinate what someone said last Tuesday. It reads the actual messages.

The Three Implementations

Three Slack MCP servers cover different needs. The choice depends on whether you need search, how you feel about write safety, and which token type you can use.

Creating a Slack App

All three servers need Slack API credentials. For bot token setups (the official and Zencoder servers), you create a Slack app and grant OAuth scopes. The korotovsky server can also use browser session tokens, which skip this step entirely.

Bot Token Setup (xoxb-)

Go to api.slack.com/apps and create a new app. Under OAuth & Permissions, add these scopes:

Install the app to your workspace. Copy the Bot User OAuth Token (starts with xoxb-) and your Team ID (starts with T, visible in your workspace URL or under Settings).

Browser Session Token Setup (xoxc/xoxd)

The korotovsky server supports browser session tokens for full API access including search. Extract these from your browser's developer tools while logged into Slack:

1. Open Slack in your browser (not the desktop app)
2. Open DevTools (F12) and go to the Network tab
3. Look for any API request to api.slack.com
4. Copy the token parameter from the request body (starts with xoxc-)
5. Copy the d cookie value from the request headers (starts with xoxd-)

Setup for Claude Code

Claude Code supports MCP servers via the CLI or a .mcp.json file. The CLI approach is fastest for personal setup. The file approach shares configuration with your team.

Official Archived Server (via npx)

claude mcp add slack \
  -e SLACK_BOT_TOKEN=xoxb-your-bot-token \
  -e SLACK_TEAM_ID=T0123456789 \
  -- npx -y @modelcontextprotocol/server-slack

korotovsky Server (via Docker)

# With browser session tokens (full access including search)
claude mcp add slack \
  -e SLACK_MCP_XOXC_TOKEN=xoxc-your-token \
  -e SLACK_MCP_XOXD_TOKEN=xoxd-your-cookie \
  -e SLACK_MCP_ADD_MESSAGE_TOOL=true \
  -- docker run -i --rm ghcr.io/korotovsky/slack-mcp-server:latest

# With bot token (limited, no search)
claude mcp add slack \
  -e SLACK_MCP_XOXB_TOKEN=xoxb-your-bot-token \
  -e SLACK_MCP_ADD_MESSAGE_TOOL=true \
  -- docker run -i --rm ghcr.io/korotovsky/slack-mcp-server:latest

Project-Scoped Configuration (.mcp.json)

For team-shared configuration, add a .mcp.json file to your project root. Token values reference environment variables so secrets stay out of version control.

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}",
        "SLACK_TEAM_ID": "${SLACK_TEAM_ID}"
      }
    }
  }
}

{
  "mcpServers": {
    "slack": {
      "command": "docker",
      "args": ["run", "-i", "--rm",
        "-e", "SLACK_MCP_XOXC_TOKEN",
        "-e", "SLACK_MCP_XOXD_TOKEN",
        "-e", "SLACK_MCP_ADD_MESSAGE_TOOL=true",
        "ghcr.io/korotovsky/slack-mcp-server:latest"
      ],
      "env": {
        "SLACK_MCP_XOXC_TOKEN": "${SLACK_MCP_XOXC_TOKEN}",
        "SLACK_MCP_XOXD_TOKEN": "${SLACK_MCP_XOXD_TOKEN}"
      }
    }
  }
}

Setup for Claude Desktop and Cursor

Claude Desktop

Edit your claude_desktop_config.json (found in ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows).

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-bot-token",
        "SLACK_TEAM_ID": "T0123456789"
      }
    }
  }
}

{
  "mcpServers": {
    "slack": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "SLACK_MCP_XOXC_TOKEN=xoxc-your-token",
        "-e", "SLACK_MCP_XOXD_TOKEN=xoxd-your-cookie",
        "-e", "SLACK_MCP_ADD_MESSAGE_TOOL=true",
        "ghcr.io/korotovsky/slack-mcp-server:latest"
      ]
    }
  }
}

Cursor

Open Cursor Settings, navigate to the MCP section, and add a new server. The JSON format matches Claude Desktop. You can also edit .cursor/mcp.json in your project root.

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-bot-token",
        "SLACK_TEAM_ID": "T0123456789"
      }
    }
  }
}

Available Tools

The number and capability of tools varies by implementation. The korotovsky server has the broadest coverage.

Official Archived Server (8 tools)

korotovsky Server (15 tools)

Comparison of Implementations

The korotovsky server wins on features, safety defaults, and maintenance. The official archived server wins on simplicity: fewer moving parts, straightforward bot token auth, and the npx install works without Docker. If you need search, DMs, or granular write controls, use korotovsky. If you need basic channel reading and posting, the official server is fine.

Safety and Write Controls

Giving an AI agent write access to your team's Slack workspace is a legitimate concern. An agent posting to the wrong channel or accidentally marking hundreds of messages as read can cause real disruption.

korotovsky Server Safety Model

Write operations are off by default. You explicitly enable each one:

# Enable posting to ALL channels
SLACK_MCP_ADD_MESSAGE_TOOL=true

# Enable posting to SPECIFIC channels only (safer)
SLACK_MCP_ADD_MESSAGE_TOOL=C0123456789,C9876543210

# Blacklist specific channels (post to all except these)
SLACK_MCP_ADD_MESSAGE_TOOL=!C0123456789

# Enable mark-as-read
SLACK_MCP_MARK_TOOL=true

# Auto-mark messages as read after sending
SLACK_MCP_ADD_MESSAGE_MARK=true

# Whitelist domains for link unfurling
SLACK_MCP_ADD_MESSAGE_UNFURLING=github.com,slack.com

Common Use Cases

Multi-Server Workflows

The Slack MCP server is most powerful when paired with other MCP servers. A typical development workflow uses three:

• Git MCP server for repository operations (diff, commit, branch, log)
• GitHub MCP server for platform operations (issues, PRs, Actions)
• Slack MCP server for team communication (reading context, posting updates)

The agent reads a Slack thread about a bug, checks the relevant code via git, creates a fix on a new branch, opens a PR on GitHub, and posts the PR link back to the Slack thread. Four MCP servers, one continuous workflow.

For codebases over 50k lines, adding WarpGrep as an MCP server gives the agent semantic code search. Instead of grep-style string matching, it finds code by meaning: "where is the payment retry logic?" returns the right files even if the code never uses the word "retry." The combination of Slack context + semantic code search lets the agent go from a Slack bug report to the relevant code in seconds.

Troubleshooting

403 Errors on Specific Operations

Missing OAuth scopes. Each tool requires specific scopes. If slack_get_channel_history returns 403, your bot is missing channels:history. Go to your Slack app settings, add the scope, and reinstall the app to the workspace.

Empty Channel History

Bot tokens (xoxb-) can only read channels the bot has been invited to. If a channel returns empty, invite the bot: type /invite @your-bot-name in that channel. Browser session tokens (xoxc/xoxd) do not have this limitation.

Search Not Working

The Slack search API is not available to bot tokens. If you need search, use the korotovsky server with browser session tokens (xoxc/xoxd) or user OAuth tokens (xoxp). The official archived server does not include a search tool at all.

Rate Limiting

Slack's API rate limits hit at roughly 1 request per second for most Web API methods. Tier 1 methods (like chat.postMessage) allow 1 request per second. Tier 3 methods (like conversations.history) allow 50+ per minute. If the agent hits rate limits during heavy use, the server will receive 429 Too Many Requests responses. The korotovsky server handles retry logic internally.

Browser Token Expiration

xoxc/xoxd tokens expire when your Slack browser session expires. If the server suddenly stops working after days/weeks, extract fresh tokens from your browser. Some users automate this with a browser extension, but there is no official supported method for long-lived xoxc tokens.

Docker Connection Issues

If Docker-based setup fails with connection errors, verify Docker is running and the image pulls successfully. Run docker run --rm ghcr.io/korotovsky/slack-mcp-server:latest --version to test. For network issues behind a corporate proxy, set SLACK_MCP_PROXY to your proxy URL.

Frequently Asked Questions

What is a Slack MCP server?

A Slack MCP server is a Model Context Protocol server that gives AI assistants direct access to your Slack workspace. It exposes tools for listing channels, reading message history, posting messages, searching conversations, adding reactions, and looking up user profiles. AI clients like Claude Code, Cursor, and Claude Desktop call these tools during conversations.

Which Slack MCP server should I use?

For most developers, korotovsky/slack-mcp-server (1,400+ stars) is the best option. It has 15 tools, supports message search, user groups, and DMs, and disables write operations by default. The official archived server is simpler (8 tools, bot token only) and works well for basic read/post workflows.

What OAuth scopes do I need?

Minimum for the official server: channels:history, channels:read, chat:write, reactions:write, users:read, users.profile:read. The korotovsky server with browser session tokens inherits your existing permissions, so no additional scopes are needed.

Can the Slack MCP server search messages?

Only with the right token type and server. Bot tokens (xoxb-) cannot access Slack's search API. The korotovsky server supports search via conversations_search_messages using browser session tokens (xoxc/xoxd) or user OAuth tokens (xoxp). The official archived server has no search tool.

Is it safe to give an AI agent write access to Slack?

The korotovsky server disables write operations by default. You explicitly enable posting via SLACK_MCP_ADD_MESSAGE_TOOL and can restrict it to specific channel IDs. This prevents accidental messages to the wrong channel. The official server enables writes by default, so the korotovsky server is safer for production use.

What is the difference between xoxb and xoxc tokens?

xoxb- tokens are bot tokens: stable, require explicit OAuth scopes, limited to invited channels, no search. xoxc- tokens are browser session tokens: inherit your full permissions, support search, access all visible channels, but expire periodically. Use xoxb for team/production use, xoxc for personal development.

Can I use this with Cursor or VS Code?

Yes. Both support MCP server configuration. The JSON format is identical to Claude Desktop. Add it to .cursor/mcp.json for Cursor or VS Code MCP settings. The server binary runs the same way regardless of the client.

How do I restrict which channels the agent can access?

The official server supports SLACK_CHANNEL_IDS as a comma-separated list of channel IDs. The korotovsky server's channel caching includes all visible channels, but write operations can be restricted to specific channel IDs via SLACK_MCP_ADD_MESSAGE_TOOL=C123,C456.

Related MCP Server Guides

• Git MCP Server: Setup, Tools, and Real Use Cases
• Best MCP Servers for Coding (2026)
• Claude Code MCP Servers Guide
• Claude Desktop MCP Setup
• LinkedIn MCP Server Guide