Skip to main content
To make your Chainlit app available on Slack, you will need to create a Slack app and set up the necessary environment variables.

​
How it Works

The Slack bot will listen to messages mentioning it in channels and direct messages. It will send replies to a dedicated thread or DM depending on the context.

​
Supported Features

MessageStreamingElementsAudioAsk UserChat HistoryChat ProfilesFeedback
✅❌✅❌❌✅❌✅

​
Install the Slack Bolt Library

The Slack Bolt library is not included in the Chainlit dependencies. You will have to install it manually. 
pip install slack_bolt

​
Create a Slack App

To start, navigate to the Slack apps dashboard for the Slack API. Here, you should find a green button that says Create New App. When you click this button, select the option to create your app from scratch. Create a name for your bot, such as “ChainlitDemo”. Select the workspace you would like your bot to exist in.

​
Connection Modes

Chainlit supports two ways to connect to Slack:
  • HTTP Mode (default): Slack sends events to your Chainlit server via HTTP. Requires a public URL.
  • Socket Mode (since 2.7.0): Chainlit connects to Slack via WebSocket. No public URL needed — ideal for local development or restrictive networks.
To use Socket Mode, set the SLACK_WEBSOCKET_TOKEN environment variable (see Environment Variables). When set, Socket Mode takes priority over the HTTP handler.

​
Working Locally

If you use Socket Mode, no public URL or ngrok is needed. Chainlit connects to Slack over WebSocket directly. See the Socket Mode app manifest below.

​
With HTTP Mode

If you are working locally with HTTP mode, you will have to expose your local Chainlit app to the internet to receive incoming messages from Slack. You can use ngrok for this. 
ngrok http 8000
This will give you a public URL that you can use to set up the app manifest. Do not forget to replace it once you deploy Chainlit to a public host.

​
Set the App Manifest

Go to App Manifest and paste the following Yaml.
Replace the {placeholders} with your own values.
display_information:
  name: { APP_NAME }
features:
  bot_user:
    display_name: { APP_NAME }
    always_online: false
oauth_config:
  scopes:
    user:
      - im:history
      - channels:history
    bot:
      - app_mentions:read
      - channels:read
      - chat:write
      - files:read
      - files:write
      - im:history
      - im:read
      - im:write
      - users:read
      - users:read.email
      - channels:history
      - groups:history
settings:
  event_subscriptions:
    request_url: https://{ CHAINLIT_APP_HOST }/slack/events
    bot_events:
      - app_home_opened
      - app_mention
      - message.im
  interactivity:
    is_enabled: true
    request_url: https://{ CHAINLIT_APP_HOST }/slack/events
  org_deploy_enabled: false
  socket_mode_enabled: false
  token_rotation_enabled: false
Click on Save Changes.
You will see a warning stating that the URL is not verified. You can ignore this for now.

​
Socket Mode

If you are using Socket Mode, apply these changes to the manifest above: remove both request_url fields and set socket_mode_enabled to true. 
settings:
  event_subscriptions:
    request_url: https://{ CHAINLIT_APP_HOST }/slack/events
    bot_events:
      - app_home_opened
      - app_mention
      - message.im
  interactivity:
    is_enabled: true
    request_url: https://{ CHAINLIT_APP_HOST }/slack/events
  org_deploy_enabled: false
  socket_mode_enabled: false
  socket_mode_enabled: true
  token_rotation_enabled: false

​
[Optional] Allow users to send DMs to Chainlit

By default the app will only listen to mentions in channels. If you want to allow users to send direct messages to the app, go to App Home and enable “Allow users to send Slash commands and messages from the messages tab”.

​
[Optional] Emoji Reaction on Message Received

Adds an optional feature to show emoji reactions when Slack messages are received, providing immediate user feedback while the bot processes the request.
This feature requires the reactions:write OAuth scope. If you enable this feature, you’ll need to add this scope to your Slack app’s OAuth configuration.
To enable this feature, add the following configuration to your chainlit.md file: 
[features.slack]
reaction_on_message_received = true
This feature is disabled by default to maintain backward compatibility. If you enable this feature, you’ll need to add the reactions:write scope to your Slack app’s OAuth configuration.

​
Install the Slack App to Your Workspace

Navigate to the Install App tab and click on Install to Workspace.

​
Set the Environment Variables

Set the environment variables outside of your application code.

​
Bot Token

Once the slack application is installed, you will see the Bot User OAuth Token. Set this as an environment variable in your Chainlit app. 
SLACK_BOT_TOKEN=your_bot_token

​
Signing Secret

Navigate to the Basic Information tab and copy the Signing Secret. Then set it as an environment variable in your Chainlit app. 
SLACK_SIGNING_SECRET=your_signing_secret

​
App-Level Token (Socket Mode only)

If you are using Socket Mode, you also need an App-Level Token. Navigate to Basic Information > App-Level Tokens, create a token with the connections:write scope, and set it as an environment variable. 
SLACK_WEBSOCKET_TOKEN=your_app_level_token
When SLACK_WEBSOCKET_TOKEN is set, Chainlit uses Socket Mode and the HTTP /slack/events endpoint is not registered. You do not need SLACK_SIGNING_SECRET in Socket Mode.

​
Start the Chainlit App

Since the Chainlit app is not running, the Slack app will not be able to communicate with it. For the example, we will use this simple app:
my_app.py
import chainlit as cl

@cl.on_message
async def on_message(msg: cl.Message):
    # Access the original slack event
    print(cl.user_session.get("slack_event"))
    # Access the slack user
    print(cl.user_session.get("user"))

    # Access potential attached files
    attached_files = msg.elements

    await cl.Message(content="Hello World").send()
Reminder: Make sure the environment variables are set. If using HTTP mode, your local Chainlit app must be exposed to the internet via ngrok.
Start the Chainlit app: 
chainlit run my_app.py -h
Using -h to not open the default Chainlit UI since we are using Slack.
You should now be able to interact with your Chainlit app through Slack.

​
Chat History

Chat history is directly available through the fetch_slack_message_history method. It will fetch the last messages from the current thread or DM channel. 
import chainlit as cl
import discord


@cl.on_message
async def on_message(msg: cl.Message):
    fetch_slack_message_history = cl.user_session.get("fetch_slack_message_history")

    if fetch_slack_message_history:
        print(await fetch_slack_message_history(limit=10))

    # Your code here