korotovsky_slack-mcp-server

Slack MCP Server

Model Context Protocol (MCP) server for Slack Workspaces. This integration supports both Stdio and SSE transports, proxy settings and does not require any permissions or bots being created or approved by Workspace admins 😏.

[!IMPORTANT]
We need your support! Each month, over 10,000 engineers visit this repository, and more than 2,000 are already using it.

If you appreciate the work our contributors have put into this project, please consider giving the repository a star.

Feature Demo

Tools

1. conversations_history

• Get messages from the channel by channelID
• Required inputs:
  • channel_id (string): ID of the channel in format Cxxxxxxxxxx or its name starting with #... aka #general.
  • include_activity_messages (bool, default: false): If true, the response will include activity messages such as 'channel_join' or 'channel_leave'. Default is boolean false.
  • cursor (string, default: ""): Cursor for pagination. Use the value of the last row and column in the response as next_cursor field returned from the previous request.
  • limit (string, default: 28): Limit of messages to fetch.
• Returns: List of messages with timestamps, user IDs, and text content

2. conversations_replies

• Get a thread of messages posted to a conversation by channelID and thread_ts
• Required inputs:
  • channel_id (string): ID of the channel in format Cxxxxxxxxxx or its name starting with #... aka #general.
  • thread_ts (string): Unique identifier of either a thread’s parent message or a message in the thread. ts must be the timestamp in format 1234567890.123456 of an existing message with 0 or more replies.
  • include_activity_messages (bool, default: false): If true, the response will include activity messages such as 'channel_join' or 'channel_leave'. Default is boolean false.
  • cursor (string, default: ""): Cursor for pagination. Use the value of the last row and column in the response as next_cursor field returned from the previous request.
  • limit (string, default: 28): Limit of messages to fetch.
• Returns: List of replies with timestamps, user IDs, and text content

3. channels_list

• Get list of channels
• Required inputs:
  • channel_types (string): Comma-separated channel types. Allowed values: 'mpim', 'im', 'public_channel', 'private_channel'. Example: 'public_channel,private_channel,im'.
  • sort (string): Type of sorting. Allowed values: 'popularity' - sort by number of members/participants in each channel.
  • limit (number, default: 100): Limit of channels to fetch.
  • cursor (string): Cursor for pagination. Use the value of the last row and column in the response as next_cursor field returned from the previous request.
• Returns: List of channels

Setup Guide

1. Authentication Setup

Open up your Slack in your browser and login.

Lookup SLACK_MCP_XOXC_TOKEN

• Open your browser's Developer Console.
• In Firefox, under Tools -> Browser Tools -> Web Developer tools in the menu bar
• In Chrome, click the "three dots" button to the right of the URL Bar, then select More Tools -> Developer Tools
• Switch to the console tab.
• Type "allow pasting" and press ENTER.
• Paste the following snippet and press ENTER to execute: JSON.parse(localStorage.localConfig_v2).teams[document.location.pathname.match(/^\/client\/([A-Z0-9]+)/)[1]].token

Token value is printed right after the executed command (it starts with xoxc-), save it somewhere for now.

Lookup SLACK_MCP_XOXD_TOKEN

• Switch to "Application" tab and select "Cookies" in the left navigation pane.
• Find the cookie with the name d. That's right, just the letter d.
• Double-click the Value of this cookie.
• Press Ctrl+C or Cmd+C to copy it's value to clipboard.
• Save it for later.

Alternative: Using SLACK_MCP_XOXP_TOKEN (User OAuth)

Instead of using browser-based tokens (XOXC/XOXD), you can use a User OAuth token:

1. Go to api.slack.com/apps and create a new app
2. Under "OAuth & Permissions", add the following scopes:
   • channels:history - View messages in public channels
   • channels:read - View basic information about public channels
   • groups:history - View messages in private channels
   • groups:read - View basic information about private channels
   • im:history - View messages in direct messages
   • im:read - View basic information about direct messages
   • mpim:history - View messages in group direct messages
   • mpim:read - View basic information about group direct messages
   • users:read - View people in a workspace
3. Install the app to your workspace
4. Copy the "User OAuth Token" (starts with xoxp-)

Note: You only need either XOXP token or both XOXC/XOXD tokens. XOXP user tokens are more secure and don't require browser session extraction.

2. Installation

Choose one of these installation methods:

• npx
• Docker

3. Configuration and Usage

You can configure the MCP server using command line arguments and environment variables.

Using npx

If you have npm installed, this is the fastest way to get started with slack-mcp-server on Claude Desktop.

Open your claude_desktop_config.json and add the mcp server to the list of mcpServers:

Option 1: Using XOXP Token

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": [
        "-y",
        "slack-mcp-server@latest",
        "--transport",
        "stdio"
      ],
      "env": {
        "SLACK_MCP_XOXP_TOKEN": "xoxp-..."
      }
    }
  }
}

Option 2: Using XOXC/XOXD Tokens

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": [
        "-y",
        "slack-mcp-server@latest",
        "--transport",
        "stdio"
      ],
      "env": {
        "SLACK_MCP_XOXC_TOKEN": "xoxc-...",
        "SLACK_MCP_XOXD_TOKEN": "xoxd-..."
      }
    }
  }
}

{
  "mcpServers": {
    "slack": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "SLACK_MCP_XOXP_TOKEN",
        "ghcr.io/korotovsky/slack-mcp-server",
        "mcp-server",
        "--transport",
        "stdio"
      ],
      "env": {
        "SLACK_MCP_XOXP_TOKEN": "xoxp-..."
      }
    }
  }
}

{
  "mcpServers": {
    "slack": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "SLACK_MCP_XOXC_TOKEN",
        "-e",
        "SLACK_MCP_XOXD_TOKEN",
        "ghcr.io/korotovsky/slack-mcp-server",
        "mcp-server",
        "--transport",
        "stdio"
      ],
      "env": {
        "SLACK_MCP_XOXC_TOKEN": "xoxc-...",
        "SLACK_MCP_XOXD_TOKEN": "xoxd-..."
      }
    }
  }
}

Using npx with sse transport:

In case you would like to run it in sse mode, then you should use mcp-remote wrapper for Claude Desktop and deploy/expose MCP server somewhere e.g. with ngrok or docker-compose.

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://x.y.z.q:3001/sse",
        "--header",
        "Authorization: Bearer ${SLACK_MCP_SSE_API_KEY}"
      ],
      "env": {
        "SLACK_MCP_SSE_API_KEY": "my-$$e-$ecret"
      }
    }
  }
}

{
  "mcpServers": {
    "slack": {
      "command": "C:\\Progra~1\\nodejs\\npx.cmd",
      "args": [
        "-y",
        "mcp-remote",
        "https://x.y.z.q:3001/sse",
        "--header",
        "Authorization: Bearer ${SLACK_MCP_SSE_API_KEY}"
      ],
      "env": {
        "SLACK_MCP_SSE_API_KEY": "my-$$e-$ecret"
      }
    }
  }
}

TLS and Exposing to the Internet

There are several reasons why you might need to setup HTTPS for your SSE.

• mcp-remote is capable to handle only https schemes;
• it is generally a good practice to use TLS for any service exposed to the internet;

You could use ngrok:

ngrok http 3001

and then use the endpoint https://903d-xxx-xxxx-xxxx-10b4.ngrok-free.app for your mcp-remote argument.

Using Docker

For detailed information about all environment variables, see Environment Variables.

export SLACK_MCP_XOXC_TOKEN=xoxc-...
export SLACK_MCP_XOXD_TOKEN=xoxd-...

docker pull ghcr.io/korotovsky/slack-mcp-server:latest
docker run -i --rm \
  -e SLACK_MCP_XOXC_TOKEN \
  -e SLACK_MCP_XOXD_TOKEN \
  slack-mcp-server mcp-server --transport stdio

Or, the docker-compose way:

wget -O docker-compose.yml https://github.com/korotovsky/slack-mcp-server/releases/latest/download/docker-compose.yml
wget -O .env https://github.com/korotovsky/slack-mcp-server/releases/latest/download/default.env.dist
nano .env # Edit .env file with your tokens from step 1 of the setup guide
docker-compose up -d

Console Arguments

Environment Variables

Debugging Tools

# Run the inspector with stdio transport
npx @modelcontextprotocol/inspector go run mcp/mcp-server.go --transport stdio

# View logs
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log

Security

• Never share API tokens
• Keep .env files secure and private

License

Licensed under MIT - see file. This is not an official Slack product.