wingetCollections
  • Auto
  • Search
  • Awesome Collections
  • Awesome Programs
  • My Favorite Collections
  • My Collections
  • Account / Settings
  • Terms of Service
  • Privacy
  • About
  • What is WinGet?

© 2026 winget.ragerworks.com

Loading...
Install Slack Chat API CLI using Winget - wingetCollections
  1. Go back
  2. Packages
  3. Slack Chat API CLI
Slack Chat API CLI logo

Slack Chat API CLI Open CLI Collective

api automation chat cli messaging slack
Use this command to install Slack Chat API CLI:
winget install --id=OpenCLICollective.slack-chat-cli -e

Slack Chat API CLI is a lightweight command-line interface designed to interact directly with the Slack Web API. It provides developers and IT professionals with a powerful toolset for automating tasks and scripting interactions within Slack, such as sending messages, managing channels, listing users, viewing message history, and searching through messages or files.

Key Features:

  • Direct API Access: Enables seamless integration with Slack’s Web API for automation and scripting.
  • Channel Management: Create, archive, modify topics, and invite users to channels.
  • Message Operations: Send, update, delete, and view message history in public and private channels.
  • User Interaction: List users, retrieve user information, and manage permissions.
  • Search Capabilities: Efficiently search through messages and files using user tokens for enhanced functionality.

Audience & Benefit:
Ideal for developers, DevOps engineers, and IT professionals seeking to automate Slack workflows. This tool streamlines team communication and operational efficiency by enabling script-driven interactions with Slack’s ecosystem, such as automating notifications or managing channel permissions directly from the command line.

Available via winget for easy installation, this CLI is a versatile addition to any automation toolkit.

README

slack-chat-cli

A lightweight command-line interface for interacting with the Slack Web API.

Not the Official Slack CLI

This project is not affiliated with Slack or Salesforce. If you're looking to build Slack apps with workflows, triggers, and datastores, check out the official Slack CLI.

What's the difference?

Featureslck (this project)Official Slack CLI
PurposeDirect API access for automation & scriptingBuild and deploy Slack apps
Use casesSend messages, manage channels, search, CI/CD integrationWorkflows, triggers, datastores, app development
AuthenticationBot/User OAuth tokensSlack app credentials
ComplexitySimple, single binaryFull development framework

When to use slck:

  • Sending notifications from CI/CD pipelines
  • Automating channel management
  • Scripting message operations
  • Quick API interactions from the terminal
  • Integrating Slack into shell scripts or automation tools

Installation

macOS

Homebrew (recommended)

brew install open-cli-collective/tap/slack-chat-cli

> Note: This installs from our third-party tap.

Windows

Chocolatey

choco install slack-chat-cli

Winget

winget install OpenCLICollective.slack-chat-cli

Linux

APT (Debian/Ubuntu)

# Add the GPG key
curl -fsSL https://open-cli-collective.github.io/linux-packages/keys/gpg.asc | sudo gpg --dearmor -o /usr/share/keyrings/open-cli-collective.gpg

# Add the repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/open-cli-collective.gpg] https://open-cli-collective.github.io/linux-packages/apt stable main" | sudo tee /etc/apt/sources.list.d/open-cli-collective.list

# Install
sudo apt update
sudo apt install slck
Versions
3.2.68
3.2.67
3.2.62
3.2.60
3.1.58
3.1.51
3.1.49
3.1.48
3.1.47
3.1.45
show 22 more
Website
github.com
License
Last updated
7/19/2026
Download latest version

> Note: This is our third-party APT repository, not official Debian/Ubuntu repos.

DNF/YUM (Fedora/RHEL/CentOS)

# Add the repository
sudo tee /etc/yum.repos.d/open-cli-collective.repo << 'EOF'
[open-cli-collective]
name=Open CLI Collective
baseurl=https://open-cli-collective.github.io/linux-packages/rpm
enabled=1
gpgcheck=1
gpgkey=https://open-cli-collective.github.io/linux-packages/keys/gpg.asc
EOF

# Install
sudo dnf install slck

> Note: This is our third-party RPM repository, not official Fedora/RHEL repos.

Binary download

Download .deb, .rpm, or .tar.gz from the Releases page - available for x64 and ARM64.

# Direct .deb install
curl -LO https://github.com/open-cli-collective/slack-chat-api/releases/latest/download/slck_VERSION_linux_amd64.deb
sudo dpkg -i slck_VERSION_linux_amd64.deb

# Direct .rpm install
curl -LO https://github.com/open-cli-collective/slack-chat-api/releases/latest/download/slck-VERSION.x86_64.rpm
sudo rpm -i slck-VERSION.x86_64.rpm

From Source

go install github.com/open-cli-collective/slack-chat-api/cmd/slck@latest

Manual Build

git clone https://github.com/open-cli-collective/slack-chat-api.git
cd slack-chat-api
make build

Platform Support

Credentials are stored in the OS keyring via the shared cli-common/credstore library:

PlatformCredential Storage
macOSKeychain
WindowsCredential Manager
LinuxSecret Service (D-Bus); fails closed if a working keyring is locked. Encrypted-file backend only when there is no keyring at all, or by explicit opt-in via --backend file, SLACK_CHAT_API_KEYRING_BACKEND=file, or keyring.backend: file in config.yml.

Tokens are never written to a plaintext file. Non-secret config (credential_ref, workspace, keyring.backend) lives in ~/.config/slack-chat-api/config.yml.

The backend can be selected by three user-configurable knobs that fall back to auto-detect, in precedence order:

  1. --backend persistent flag (highest)
  2. SLACK_CHAT_API_KEYRING_BACKEND= environment variable
  3. keyring.backend: in config.yml
  4. OS default (auto)

Supported names: keychain, wincred, secret-service, file, memory. slck config show reports the selected backend, its source, and the keyring.backend value from config.yml when set.

Credential Resolution

At runtime the only source of a token is the OS keyring. Environment variables are not read as credentials at runtime (per the Open CLI Collective Secret-Handling Standard §1.11) — they are accepted only as ingress during setup, e.g. slck init --bot-token-from-env SLACK_BOT_TOKEN or op read ... | slck set-credential --key bot_token --stdin.

> Migrating from an older slck? On first run, any tokens from a previous > version (old macOS Keychain items under service slck/slack-chat-api, or > the legacy ~/.config/slack-chat-api/credentials file) are moved into the > keyring automatically, once, then the originals are removed. A one-line > notice is printed to stderr.

Authentication

Quick Setup (2 minutes)

  1. Go to api.slack.com/apps → Create New App → From an app manifest

  2. Select your workspace

  3. Paste this manifest (JSON tab recommended):

    {
  "display_information": {
    "name": "Slack Chat API"
  },
  "features": {
    "bot_user": {
      "display_name": "Slack Chat API",
      "always_online": false
    }
  },
  "oauth_config": {
    "scopes": {
      "bot": [
        "channels:history",
        "channels:manage",
        "channels:read",
        "chat:write",
        "emoji:read",
        "files:read",
        "groups:history",
        "groups:read",
        "reactions:write",
        "team:read",
        "users:read"
      ],
      "user": [
        "search:read"
      ]
    }
  },
  "settings": {
    "org_deploy_enabled": false,
    "socket_mode_enabled": false
  }
}

    YAML alternative (if you prefer)

    display_information:
  name: Slack Chat API
features:
  bot_user:
    display_name: Slack Chat API
    always_online: false
oauth_config:
  scopes:
    bot:
      - "channels:history"
      - "channels:manage"
      - "channels:read"
      - "chat:write"
      - "emoji:read"
      - "files:read"
      - "groups:history"
      - "groups:read"
      - "reactions:write"
      - "team:read"
      - "users:read"
    user:
      - "search:read"
settings:
  org_deploy_enabled: false
  socket_mode_enabled: false

    Extended manifest — every read scope slck can use, plus all writes (DMs, group DMs, file uploads, canvas CRUD, etc.)

    Use this if you want maximum capability out of the box — reading DMs and group DMs, uploading file attachments to any channel/DM/group-DM, creating/editing/deleting canvases, resolving @subteam mentions, extended user profile data, etc. Every scope here is either needed by an existing slck command or unlocks a capability that commonly extends one (e.g. im:history so slck messages thread works on DMs, files:write for slck messages send --file, canvases:write for slck canvas create).

    {
  "display_information": {
    "name": "Slack Chat API"
  },
  "features": {
    "bot_user": {
      "display_name": "Slack Chat API",
      "always_online": false
    }
  },
  "oauth_config": {
    "scopes": {
      "bot": [
        "app_mentions:read",
        "bookmarks:read",
        "calls:read",
        "canvases:read",
        "canvases:write",
        "channels:history",
        "channels:manage",
        "channels:read",
        "chat:write",
        "chat:write.public",
        "dnd:read",
        "emoji:read",
        "files:read",
        "files:write",
        "groups:history",
        "groups:read",
        "groups:write",
        "im:history",
        "im:read",
        "im:write",
        "links:read",
        "lists:read",
        "metadata.message:read",
        "mpim:history",
        "mpim:read",
        "mpim:write",
        "pins:read",
        "reactions:read",
        "reactions:write",
        "reminders:read",
        "remote_files:read",
        "search:read.files",
        "search:read.mpim",
        "search:read.public",
        "search:read.users",
        "team:read",
        "usergroups:read",
        "users.profile:read",
        "users:read",
        "users:read.email"
      ],
      "user": [
        "bookmarks:read",
        "calls:read",
        "canvases:read",
        "canvases:write",
        "channels:history",
        "channels:read",
        "channels:write",
        "channels:write.invites",
        "channels:write.topic",
        "chat:write",
        "dnd:read",
        "emoji:read",
        "files:read",
        "files:write",
        "groups:history",
        "groups:read",
        "groups:write",
        "im:history",
        "im:read",
        "im:write",
        "links:read",
        "lists:read",
        "mpim:history",
        "mpim:read",
        "mpim:write",
        "pins:read",
        "reactions:read",
        "reactions:write",
        "reminders:read",
        "remote_files:read",
        "search:read",
        "search:read.files",
        "search:read.im",
        "search:read.mpim",
        "search:read.private",
        "search:read.public",
        "search:read.users",
        "team:read",
        "usergroups:read",
        "users.profile:read",
        "users:read",
        "users:read.email"
      ]
    },
    "pkce_enabled": false
  },
  "settings": {
    "org_deploy_enabled": false,
    "socket_mode_enabled": false,
    "token_rotation_enabled": false,
    "is_mcp_enabled": false
  }
}

    Upgrading an existing install? Paste the full manifest above into your app's Features → App Manifest tab (replacing the previous manifest), click Save Changes, then click Install App → Reinstall to Workspace to grant the new scopes. Copy both refreshed tokens and run slck init, or store them separately with slck set-credential --key bot_token --stdin and slck set-credential --key user_token --stdin.

  4. Click Create → Install to Workspace → Allow

  5. Copy the Bot User OAuth Token (starts with xoxb-)

  6. Run the interactive setup:

    slck init
# Paste your token when prompted (input is not echoed back)

Your token is stored in the OS keyring (Keychain / Credential Manager / Secret Service). It is never written to a plaintext file.

NOTE: The default manifest keeps the user token search-only. To run other commands with --as-user, use the extended manifest above; it includes the supported user equivalents for every current slck operation.

Scripted / non-interactive setup

The token is read only from stdin or a named env var — never a flag or positional value (so it can't leak via shell history or ps):

# From a pipe (preferred for automation):
op read 'op://Personal/slck/bot_token' | slck set-credential --key bot_token --stdin

# Or, during full init, from a named env var (the env var is consumed at
# setup time only; it is NOT read on subsequent runs):
slck init --bot-token-from-env SLACK_BOT_TOKEN --user-token-from-env SLACK_USER_TOKEN

1Password integration

Because the token lives in the keyring after setup, you do not wrap every invocation in op. Stage it once:

op read 'op://Personal/slck/bot_token'  | slck set-credential --key bot_token  --stdin
op read 'op://Personal/slck/user_token' | slck set-credential --key user_token --stdin

Replace the op://… references with your own 1Password secret references. Re-run only when the token rotates.

Required Scopes

The manifest above includes these scopes:

ScopePurpose
channels:readList public channels, get channel info
channels:historyRead message history from public channels
channels:manageCreate, archive, set topic/purpose, invite users
chat:writeSend, update, delete messages
emoji:readList custom workspace emoji
files:readDownload files, get file info
groups:readList private channels
groups:historyRead message history from private channels
reactions:writeAdd/remove reactions
team:readGet workspace info
users:readList users, get user info
search:readSearch messages and files (user token only)

The extended manifest (see the collapsible section above) adds these capabilities on top of the default:

ScopeUnlocks
im:history / im:read / im:writeRead messages in DMs, list DMs, open new DMs to post to
mpim:history / mpim:read / mpim:writeSame for multi-person DMs (group DMs)
files:writeUpload files — slck messages send --file in any channel/DM/group-DM
canvases:writeCreate, edit, delete canvases — slck canvas create/edit/delete
groups:writeCreate/archive private channels
chat:write.publicPost to public channels the bot isn't a member of
users.profile:readExtended user profile (status, timezone, custom fields)
users:read.emailInclude email addresses in user lookup output
usergroups:readResolve @subteam / user-group mentions
app_mentions:readReceive @-mention events (needed for event subscriptions)
reactions:readList reactions on a message
Other *:read scopes (bookmarks, pins, reminders, links, lists, calls, dnd, metadata.message, remote_files)Read-only access to those domains; mostly forward-compat for commands that may use them

Token Types

This CLI supports two types of Slack tokens:

Token TypePrefixCommandsHow to Get
Bot tokenxoxb-channels, users, messages, workspaceOAuth & Permissions → Bot User OAuth Token
User tokenxoxp-search; any command run with --as-user when the matching user scopes are grantedOAuth & Permissions → User OAuth Token

Most commands use the bot token. Search commands require a user token.

Setting up both tokens:

# Bot token (for channels, users, messages, workspace)
op read 'op://Personal/slck/bot_token'  | slck set-credential --key bot_token  --stdin

# User token (for search)
op read 'op://Personal/slck/user_token' | slck set-credential --key user_token --stdin

Or run slck init for a guided, interactive setup of both.

Getting a user token:

  1. Go to api.slack.com/apps → Your app
  2. OAuth & Permissions → User Token Scopes → Add search:read
  3. Reinstall app to workspace (if already installed)
  4. Copy the User OAuth Token (starts with xoxp-)

For broad --as-user access instead of search-only access, apply the extended manifest above before reinstalling.

Setup-time env-var ingress (read once during slck init, never at runtime):

FlagDescription
slck init --bot-token-from-env NAMERead the bot token from env var NAME at setup
slck init --user-token-from-env NAMERead the user token from env var NAME at setup

Global Flags

These flags are available on all commands:

FlagShortDefaultDescription
--output-otextOutput format: text, json, or table
--no-colorfalseDisable colored output
--as-userfalseUse user token
--as-botfalseUse bot token
--version-vShow version information
--help-hShow help for any command

Choosing Between Bot and User Tokens

By default, all commands other than search use your bot token. You can set the SLCK_AS_USER env var to true to make your user token the default. You can also use flags to specify which token to use for any specific command (and this will override the default behavior set by your env var).

# Send a message as yourself (using user token)
slck messages send --as-user C1234567890 "Hey team!"

# Set default to user token via environment variable
export SLCK_AS_USER=true
slck messages send C1234567890 "Uses user token by default"

# If the default is user token, you can override back to bot token for a specific command
export SLCK_AS_USER=true
slck messages send --as-bot C1234567890 "Uses bot token"

Usage

Channels

# List all channels
slck channels list

# List with options
slck channels list --types public_channel,private_channel  # Include private channels
slck channels list --limit 50                              # Limit results
slck channels list --exclude-archived=false                # Include archived channels

# Get channel info
slck channels get C1234567890

# Create a channel
slck channels create my-new-channel
slck channels create private-channel --private

# Archive/unarchive
slck channels archive C1234567890
slck channels unarchive C1234567890

# Set topic/purpose
slck channels set-topic C1234567890 "New topic"
slck channels set-purpose C1234567890 "Channel purpose"

# Invite users
slck channels invite C1234567890 U1111111111 U2222222222

Channels Command Reference

CommandFlagsDescription
list--types, --limit, --exclude-archivedList channels
get Get channel details
create --privateCreate a channel
archive --forceArchive a channel (prompts for confirmation)
unarchive Unarchive a channel
set-topic Set channel topic
set-purpose Set channel purpose
invite ...Invite users to channel

Users

# List all users
slck users list
slck users list --limit 50

# Get user info
slck users get U1234567890

# Search users
slck users search "john"
slck users search "john@company.com" --field email
slck users search "John Smith" --field display_name
slck users search "bot" --include-bots

Users Command Reference

CommandFlagsDescription
list--limitList all users
get Get user details
search --limit, --field, --include-botsSearch users by name, email, or display name

Users Search Flags

FlagDefaultDescription
--limit1000Maximum users to search through
--fieldallSearch field: all, name, email, display_name
--include-botsfalseInclude bot users in results

Messages

# Send a message (uses Block Kit formatting by default)
slck messages send C1234567890 "Hello, *world*!"

# Send using --channel flag (alternative to positional arg)
slck messages send --channel general "Hello team"

# Send a direct message to a user (by user ID or @handle; requires im:write scope)
slck messages send U1234567890 "Hey, got a minute?"
slck messages send @alice "Hey, got a minute?"

# Send from stdin (use "-" as text argument)
echo "Hello from stdin" | slck messages send C1234567890 -
cat message.txt | slck messages send C1234567890 -

# Send plain text (no formatting)
slck messages send C1234567890 "Plain text" --simple

# Send with custom Block Kit blocks
slck messages send C1234567890 "Fallback" --blocks '[{"type":"section","text":{"type":"mrkdwn","text":"*Bold*"}}]'

# Reply in a thread
slck messages send C1234567890 "Thread reply" --thread 1234567890.123456

# Upload files with a message
slck messages send C1234567890 "Here's the report" --file ./report.csv
slck messages send C1234567890 --file ./a.csv --file ./b.csv

# Update a message
slck messages update C1234567890 1234567890.123456 "Updated text"
slck messages update C1234567890 1234567890.123456 "Plain update" --simple

# Delete a message
slck messages delete C1234567890 1234567890.123456

# Get channel history
slck messages history C1234567890
slck messages history C1234567890 --limit 50
slck messages history C1234567890 --oldest 1234567890.000000  # After this time
slck messages history C1234567890 --latest 1234567890.000000  # Before this time

# Get thread replies
slck messages thread C1234567890 1234567890.123456
slck messages thread C1234567890 1234567890.123456 --limit 50
slck messages thread C1234567890 1234567890.123456 --since 1234567890.000000  # Only newer replies

# Add/remove reactions
slck messages react C1234567890 1234567890.123456 thumbsup
slck messages unreact C1234567890 1234567890.123456 thumbsup

Messages Command Reference

CommandFlagsDescription
send --thread, --blocks, --simple, --channel, --fileSend a message (use - for stdin)
update --blocks, --simpleUpdate a message
delete --forceDelete a message (prompts for confirmation)
history --limit, --oldest, --latestGet channel history
thread --limit, --sinceGet thread replies
react Add reaction
unreact Remove reaction

Search

> Note: Search requires a user token (xoxp-*). See Token Types.

# Search messages
slck search messages "quarterly report"
slck search messages "in:#general bug fix"
slck search messages "from:@alice project update"

# Search files
slck search files "budget spreadsheet"
slck search files "type:pdf report"

# Search all (messages + files)
slck search all "project proposal"
slck search all "quarterly" --sort timestamp

# With pagination
slck search messages "error" --count 50 --page 2

# Using query builder flags (alternative to modifiers in query string)
slck search messages "meeting" --in "#general"
slck search messages "update" --from "@alice"
slck search messages "report" --scope public
slck search messages "project" --after 2025-01-01 --before 2025-12-31
slck search messages "link" --has-link
slck search files "document" --type pdf

Search Modifiers

ModifierExampleDescription
in:in:#channel or in:@userSearch in specific channel or DM
from:from:@usernameContent from specific user
before:before:2025-01-01Before date
after:after:2025-01-01After date
has:linkMessages containing links
has:reactionMessages with reactions
type:type:pdfFiles of specific type

Search Command Reference

CommandFlagsDescription
messages --count, --page, --sort, --sort-dir, --highlight, --scope, --in, --from, --after, --before, --has-link, --has-reactionSearch messages
files --count, --page, --sort, --sort-dir, --highlight, --scope, --in, --from, --after, --before, --type, --has-pinSearch files
all --count, --page, --sort, --sort-dir, --highlight, --scope, --in, --from, --after, --before, --has-link, --has-reactionSearch messages and files

Search Flags

FlagShortDefaultDescription
--count-c20Results per page (max 100)
--page-p1Page number (max 100)
--sort-sscoreSort by: score or timestamp
--sort-dirdescSort direction: asc or desc
--highlightfalseHighlight matching terms

Query Builder Flags

These flags provide an alternative to using modifiers in the query string:

FlagDescription
--scopeSearch scope: all, public, private, dm, mpim
--inFilter by channel (e.g., #general or general)
--fromFilter by user (e.g., @alice or alice)
--afterContent after date (YYYY-MM-DD)
--beforeContent before date (YYYY-MM-DD)
--has-linkMessages containing links
--has-reactionMessages with reactions
--typeFile type filter (files only, e.g., pdf, image)
--has-pinFiles that are pinned (files only)

Workspace

# Get workspace info
slck workspace info

Emoji

# List custom workspace emoji
slck emoji list

# Include aliases
slck emoji list --include-aliases

Emoji Command Reference

CommandFlagsDescription
list--include-aliasesList custom workspace emoji

Files

# Download a file by ID
slck files download F0AHF3NUSQK

# Download to a specific path
slck files download F0AHF3NUSQK --output report.pdf

# Download using a Slack file URL
slck files download "https://files.slack.com/files-pri/T.../F0AHF3NUSQK/file.csv"

Files Command Reference

CommandFlagsDescription
download --output, -ODownload a Slack file

Canvas

# Create a standalone canvas
slck canvas create --title "Sprint Review" --text "# Sprint Review\n\nContent here"
slck canvas create --title "Report" --file report.md
echo "# Report" | slck canvas create --title "Report" --file -

# Create a channel canvas (pinned to channel tab)
slck canvas create --channel C1234567890 --file runbook.md

# Edit a canvas
slck canvas edit F12345ABC --text "# Updated content"
slck canvas edit F12345ABC --file updated.md

# Delete a canvas
slck canvas delete F12345ABC

Canvas Command Reference

CommandFlagsDescription
create--title, --text, --file, --channelCreate a standalone or channel canvas
edit --text, --fileReplace canvas content
delete Delete a canvas

> Note: Canvas commands require additional Slack app scopes not included in the default manifest. See Slack Canvas API docs for required scopes.

Identity

# Show authenticated identity (bot, user, workspace)
slck me

Config

# Guided interactive setup (bot + optional user token)
slck init

# Set one credential from stdin (scriptable; no value on the command line)
op read 'op://Personal/slck/bot_token' | slck set-credential --key bot_token --stdin

# Show current config status (backend, ref, which keys present — never values)
slck config show

# Delete stored token(s)
slck config delete-token

Config Command Reference

Ingress is at the top level, not under config:

CommandFlagsDescription
slck init--bot-token-from-env, --user-token-from-env, --bot-token-stdin, --overwrite, --no-verifyGuided setup; stores into the keyring
slck set-credential--key, --stdin, --from-env, --refSet one credential (stdin/env only)

config subcommands (none accept a secret value):

CommandFlagsDescription
set-tokenRemoved — errors out, points to set-credential
showShow backend, ref, which keys are present (never values)
delete-token--force, --typeDelete stored token(s)
testTest authentication for configured tokens

The delete-token command accepts a --type flag:

  • --type bot - Delete only the bot token
  • --type user - Delete only the user token
  • --type all - Delete both tokens (default)

Output Formats

All commands support multiple output formats via the --output (or -o) flag:

# Default text output
slck channels list

# Table output (aligned columns)
slck channels list --output table

Breaking change (#173): resource -o json has been removed. JSON is reserved for control-plane envelopes per cli-common docs/output-and-rendering.md §2. The surviving JSON surface is slck config show --json (diagnostic; emits the credential/backend status as a JSON envelope).

Shell Completion

# Bash
slck completion bash > /etc/bash_completion.d/slck

# Zsh
slck completion zsh > "${fpath[1]}/_slck"

# Fish
slck completion fish > ~/.config/fish/completions/slck.fish

# PowerShell
slck completion powershell > slck.ps1

Aliases

Commands have convenient aliases:

CommandAliases
canvascv
channelsch
usersu
messagesmsg, m
searchs
emojie
workspacews, team

Environment Variables

VariableDescription
SLCK_AS_USERSet to true or 1 to default to user token instead of bot token
SLACK_CHAT_API_KEYRING_BACKENDSelect the keyring backend. Accepts keychain, wincred, secret-service, file, memory. Precedence: --backend flag > this env var > keyring.backend in config.yml > OS auto-detect (§1.4)
SLACK_CHAT_API_KEYRING_PASSPHRASEPassphrase for the encrypted-file backend (the one runtime secret-env exception, §1.4)
NO_COLORDisable colored output when set
XDG_CONFIG_HOMECustom config directory (default: ~/.config)

> SLACK_API_TOKEN / SLACK_USER_TOKEN are no longer read at runtime > (§1.11). Use slck init --bot-token-from-env / slck set-credential to > stage a token into the keyring instead.

Known Limitations

Message Length Limits

Slack silently truncates messages exceeding 40,000 characters. slck validates message length before sending and returns an error with suggestions:

  • Upload as a file: slck messages send C123 --file ./content.txt
  • Create a canvas: slck canvas create --title "Title" --file ./content.md

Unarchiving Channels

Bot tokens (xoxb-) cannot unarchive channels due to a Slack API limitation. When a channel is archived, the bot is automatically removed from it, and bot tokens require membership to unarchive.

Workarounds:

  • Unarchive channels via the Slack UI
  • Use a user token (xoxp-) instead of a bot token

License

MIT