How to Build an OpenClaw Bot for Discord & Slack (2026)

Most people run OpenClaw through Telegram or a web UI. But if your team lives in Discord or Slack — and in 2026, most teams do — you are leaving OpenClaw's best use case on the table: an AI teammate that actually participates in your workspace.

An OpenClaw Discord bot can triage support tickets in real time. An OpenClaw Slack bot can run daily standups, summarize meeting threads, and answer questions from your company knowledge base. These are not toys. They are the automations that save teams 5-10 hours per week.

This guide walks you through setting up OpenClaw as a Discord bot and a Slack bot, from creating the app credentials to configuring OpenClaw's messaging skills. We will cover real use cases, security best practices, and cost expectations — so you can deploy a team bot with confidence.

If you are using ClawPod and only need the fastest Discord setup path, start with How to Connect a Discord Bot to ClawPod.

If you are new to OpenClaw, start with What is OpenClaw? for the fundamentals, or jump to How to Install OpenClaw if you need to get a running instance first.

Prerequisites

Before you start, you need:

1. A running OpenClaw instance — self-hosted on a VPS, running locally, or deployed via ClawPod. The instance must be accessible over the internet (not just localhost) to receive webhook events from Discord and Slack.
2. An AI provider API key — Anthropic, OpenAI, Google, or OpenRouter. If you are unsure which model to use, Claude Sonnet 4 via OpenRouter is a solid default for team bots.
3. Admin access to your Discord server or Slack workspace — You need permission to install apps/bots.

If you are running OpenClaw locally behind a NAT or firewall, you will need to set up port forwarding or use a tunnel like ngrok. This is one of the biggest pain points for self-hosters — and the main reason managed hosting like ClawPod exists. With ClawPod, your instance is already internet-accessible with SSL, so you can skip straight to bot configuration.

Part 1: Building an OpenClaw Discord Bot

Step 1 — Create a Discord Application

Go to the Discord Developer Portal and click New Application.

1. Name your application (e.g., "Team Assistant" or your company name)
2. Accept the Terms of Service
3. You will land on the General Information page — note the Application ID, you will need it later

Step 2 — Create the Bot User

Navigate to the Bot section in the left sidebar.

1. Click Reset Token to generate a new bot token
2. Copy the token immediately — Discord only shows it once

# Example token format (this is not a real token)
MTIzNDU2Nzg5MDEyMzQ1Njc4.GAbCdE.abcdefghijklmnopqrstuvwxyz1234567890

Critical: Store this token securely. Never commit it to a Git repository, paste it in a public channel, or share it in screenshots. If you need a refresher on token security, read our OpenClaw Security Guide.

3. Under Privileged Gateway Intents, enable:
   • Message Content Intent — Required for OpenClaw to read message text
   • Server Members Intent — Optional, but useful if your bot needs to reference users by name
   • Presence Intent — Optional, only needed for presence-based triggers

Step 3 — Set Bot Permissions

Navigate to OAuth2 > URL Generator.

1. Under Scopes, select:

   • bot
   • applications.commands (if you want slash commands)

2. Under Bot Permissions, select:

   • Send Messages
   • Read Message History
   • Embed Links
   • Attach Files
   • Use Slash Commands
   • Add Reactions
   • Manage Threads (optional, for thread-based conversations)

3. Copy the generated URL and open it in your browser to invite the bot to your server

For team bots, resist the temptation to grant Administrator permissions. Principle of least privilege applies — only give the bot what it actually needs. You can always add permissions later if a use case requires them.

Step 4 — Configure OpenClaw

Now connect Discord to your OpenClaw instance. Edit your OpenClaw configuration file:

# config.yaml
messaging:
  discord:
    enabled: true
    token: '${DISCORD_BOT_TOKEN}' # Set via environment variable
    command_prefix: '!' # Optional: trigger with !ask, !help, etc.
    allowed_channels: # Optional: restrict to specific channels
      - 'bot-commands'
      - 'team-support'
      - 'general'
    allowed_roles: # Optional: restrict to specific roles
      - 'Team Member'
      - 'Admin'
    thread_mode: true # Reply in threads to keep channels clean
    max_message_length: 2000 # Discord's character limit

Set the token as an environment variable — never hardcode it in the config file:

# .env file (never commit this)
DISCORD_BOT_TOKEN=MTIzNDU2Nzg5MDEyMzQ1Njc4.GAbCdE.abcdefghijklmnopqrstuvwxyz1234567890

Step 5 — Start and Test

Restart your OpenClaw instance to pick up the new configuration:

# If running with Docker
docker compose restart openclaw

# If running directly
openclaw restart

Go to a channel where the bot has access and send a test message:

!ask What is the capital of France?

If the bot responds, your Discord integration is live. If not, check:

• The bot token is correct and not expired
• The bot has been invited to the server (Step 3)
• Message Content Intent is enabled (Step 2)
• The channel is in allowed_channels (or remove that setting to allow all channels)
• Your OpenClaw instance logs for error messages

Discord-Specific Tips

Thread mode is essential for team channels. Without it, the bot's responses clutter the main channel. With thread_mode: true, every conversation automatically happens in a thread — keeping the channel clean and allowing multiple parallel conversations.

Use channel restrictions aggressively. A bot that responds to every message in every channel is annoying. Limit it to dedicated channels (like #bot-commands or #ask-ai) and specific trigger channels where automation makes sense.

Slash commands provide a better UX. Instead of !ask <question>, users can type /ask and get autocomplete, parameter hints, and a cleaner interface. OpenClaw supports registering Discord slash commands — enable them in your config:

messaging:
  discord:
    slash_commands:
      enabled: true
      commands:
        - name: ask
          description: 'Ask the AI assistant a question'
        - name: summarize
          description: 'Summarize the last N messages in this channel'
        - name: standup
          description: "Post today's standup summary"

Part 2: Building an OpenClaw Slack Bot

Slack's setup is more involved than Discord because of its OAuth-based architecture, but the result is more powerful — Slack bots get deeper workspace integration, richer message formatting, and native support for interactive elements like buttons and modals.

Step 1 — Create a Slack App

Go to the Slack API portal and click Create New App.

1. Choose From scratch
2. Name your app (e.g., "OpenClaw Assistant")
3. Select the workspace where you want to install it

Step 2 — Configure OAuth & Permissions

Navigate to OAuth & Permissions in the left sidebar.

Under Bot Token Scopes, add these scopes:

channels:history      # Read messages in public channels
channels:read         # View basic channel info
chat:write            # Send messages
groups:history        # Read messages in private channels (if needed)
groups:read           # View basic private channel info
im:history            # Read DMs with the bot
im:read               # View basic DM info
im:write              # Start DMs with users
reactions:read        # See emoji reactions
reactions:write       # Add emoji reactions
users:read            # View user profiles (for @mentions)
files:read            # Read shared files (optional)

Do not add scopes you don't need. Every scope is a potential attack surface. If your bot only operates in public channels, skip groups:history and groups:read.

Step 3 — Enable Event Subscriptions

Navigate to Event Subscriptions and toggle it on.

For the Request URL, enter your OpenClaw instance's webhook endpoint:

https://your-openclaw-domain.com/api/webhooks/slack

If you are using ClawPod, this URL is automatically configured and SSL-secured. For self-hosted instances, you need a valid SSL certificate — Slack rejects plain HTTP endpoints.

Under Subscribe to bot events, add:

message.channels      # Messages in public channels
message.groups        # Messages in private channels
message.im            # Direct messages to the bot
app_mention           # When someone @mentions your bot
reaction_added        # When someone reacts to a message (optional)

Recommended approach: Start with only app_mention and message.im. This means the bot only responds when someone explicitly @mentions it or DMs it directly — the least intrusive setup. Add channel-wide message events later if you need proactive monitoring.

Step 4 — Install to Workspace

Go to Install App in the left sidebar and click Install to Workspace. Authorize the requested permissions.

After installation, you will see two tokens:

• Bot User OAuth Token (starts with xoxb-) — This is the one OpenClaw needs
• User OAuth Token (starts with xoxp-) — You do not need this for most use cases

Copy the Bot User OAuth Token.

You will also need the Signing Secret from the Basic Information page — OpenClaw uses this to verify that incoming webhook requests are genuinely from Slack, not from an attacker.

Step 5 — Configure OpenClaw

Edit your OpenClaw configuration:

# config.yaml
messaging:
  slack:
    enabled: true
    bot_token: '${SLACK_BOT_TOKEN}'
    signing_secret: '${SLACK_SIGNING_SECRET}'
    app_token: '${SLACK_APP_TOKEN}' # Only needed for Socket Mode
    mode: 'webhook' # "webhook" or "socket"
    allowed_channels:
      - 'bot-commands'
      - 'engineering'
      - 'support-internal'
    response_type: 'thread' # Reply in threads
    unfurl_links: false # Don't preview links in bot messages
    markdown: true # Use Slack mrkdwn formatting

Set the credentials as environment variables:

# .env file (never commit this)
SLACK_BOT_TOKEN=xoxb-1234567890-1234567890123-AbCdEfGhIjKlMnOpQrStUvWx
SLACK_SIGNING_SECRET=abc123def456ghi789jkl012mno345pq

Webhook vs Socket Mode: Webhook mode requires your OpenClaw instance to have a public URL with SSL. Socket Mode uses a WebSocket connection initiated from your server, so it works behind firewalls without port forwarding. If you are self-hosting behind a NAT, Socket Mode is easier. If you are on ClawPod or any internet-facing server, Webhook mode is more reliable and lower-latency.

Step 6 — Start and Test

Restart OpenClaw and test in Slack:

@OpenClaw Assistant What are today's priorities?

Or send a direct message to the bot. If it responds, you are live.

Troubleshooting checklist:

• Verify the Bot User OAuth Token is correct (starts with xoxb-)
• Confirm the Signing Secret matches (from Basic Information, not OAuth page)
• Check that Event Subscriptions shows a green checkmark for your Request URL
• Ensure the bot has been invited to the channel (/invite @OpenClaw Assistant)
• Review OpenClaw instance logs for incoming webhook events

Real-World Use Cases for Team Bots

Setting up the integration is the easy part. The real value comes from what you do with it. Here are five proven use cases that teams deploy with OpenClaw Discord and Slack bots.

1. Automated Daily Standups

Configure your bot to post a standup prompt every morning at 9:00 AM and collect responses throughout the day:

skills:
  standup:
    schedule: '0 9 * * 1-5' # Monday-Friday at 9 AM
    channel: 'standups'
    prompt: |
      Post the daily standup prompt. Ask team members to reply with:
      1. What they completed yesterday
      2. What they're working on today
      3. Any blockers
      At 5 PM, compile all responses into a summary and post it.

The bot collects responses as they come in, then generates an end-of-day summary that highlights blockers, identifies overlapping work, and flags anyone who did not report. This replaces a 15-minute synchronous meeting that interrupts everyone's flow.

2. Ticket Triage and Routing

Connect your bot to a support channel where customers or team members report issues:

skills:
  ticket-triage:
    trigger: 'channel:support-requests'
    actions:
      - classify: [bug, feature_request, question, urgent]
      - route:
          bug: '#engineering-bugs'
          feature_request: '#product-backlog'
          question: '#faq-responses'
          urgent: '#on-call'
      - acknowledge: true # Reply to the reporter with classification and next steps

The bot reads each incoming message, classifies it by type and urgency, routes it to the appropriate channel, and sends the reporter an acknowledgment with expected response times. Teams using this pattern report 60-70% faster first-response times on support tickets.

3. Knowledge Base Q&A

This is the use case that makes executives excited. Load your company documentation, wiki, or SOPs into OpenClaw's memory, and team members can ask questions in natural language:

skills:
  knowledge-base:
    trigger: '@bot'
    sources:
      - type: file
        path: /data/company-wiki/
      - type: notion
        database_id: 'abc123...'
      - type: confluence
        space_key: 'ENG'
    prompt: |
      Answer questions using only the provided knowledge base.
      If the answer is not in the knowledge base, say so clearly.
      Always cite the source document.

Instead of searching through Confluence for 15 minutes, team members ask @bot How do I request PTO? and get an instant answer with a link to the source document. This scales particularly well — the bot handles the same question from 50 different people without getting tired of repeating itself.

4. Meeting Summaries and Action Items

After a meeting, paste the transcript (or have your meeting tool send it) to the bot:

@bot Summarize this meeting transcript and extract action items with owners and deadlines:

[paste transcript]

The bot generates a structured summary with:

• Key decisions made
• Action items with assigned owners
• Open questions that need follow-up
• Deadlines mentioned

For teams that run 5-10 meetings per day, this saves 30-60 minutes of manual note-taking and ensures nothing falls through the cracks.

5. Incident Response Coordination

For engineering teams, configure the bot to help manage incidents:

skills:
  incident:
    trigger: '!incident'
    actions:
      - create_channel: 'incident-{date}-{short_description}'
      - invite: ['@on-call-engineer', '@engineering-lead']
      - post_template: |
          **Incident Opened:** {description}
          **Severity:** {severity}
          **On-Call:** {on_call}
          **Status:** Investigating

          Please post updates in this channel. I will compile a timeline.
      - monitor: true # Track all messages and generate a timeline
      - post_mortem: true # Generate a post-mortem draft when incident is resolved

When someone types !incident API latency spike - P1, the bot creates a dedicated channel, invites the right people, posts a structured template, and monitors the conversation to auto-generate an incident timeline and post-mortem draft.

Security Considerations

Running a bot that has access to your team's conversations requires careful security planning. Here are the non-negotiable practices.

Token Management

• Never hardcode tokens in configuration files that might be committed to version control. Use environment variables or a secrets manager.
• Rotate tokens quarterly. Discord and Slack both allow you to regenerate tokens. Old tokens are immediately invalidated.
• Use separate tokens for development and production. Your test bot and production bot should be different Slack/Discord apps with different credentials.
• Monitor token usage. Unexpected API calls or messages from your bot that you did not trigger are signs of a compromised token.

For a comprehensive security checklist, see our OpenClaw Security Guide.

Permission Scoping

Discord: Use channel restrictions and role-based access. The bot should not have access to channels like #hr-confidential or #exec-strategy unless explicitly needed.

Slack: Apply the principle of least privilege to OAuth scopes. Start with the minimum set and add scopes only when a specific feature requires them. Regularly audit your app's scopes in the Slack admin dashboard.

Rate Limiting

Both Discord and Slack enforce rate limits. If your bot exceeds them, it gets temporarily blocked — or permanently banned in extreme cases.

• Discord: 50 messages per channel per 10 seconds; 5 API requests per second globally
• Slack: 1 message per second per channel; varies by endpoint for the Web API

OpenClaw handles rate limiting automatically in most cases, but if you are running a bot that responds to high-traffic channels, add a cooldown:

messaging:
  rate_limit:
    messages_per_minute: 20
    cooldown_seconds: 3

Data Privacy

Your bot processes every message in the channels it monitors. That means:

• Conversation data is sent to your AI provider (Anthropic, OpenAI, etc.) for processing. Make sure your team knows this.
• Message logs may be stored in OpenClaw's conversation history. Configure retention policies.
• Sensitive channels should be excluded from bot monitoring entirely.

If your company has compliance requirements (SOC 2, GDPR, HIPAA), consult your security team before deploying an AI bot that reads internal communications.

Cost Breakdown: Running Team Bots

How much does it cost to run an OpenClaw team bot? Here is a realistic breakdown for a 10-person engineering team.

API Costs

These estimates use Claude Sonnet 4 pricing ($3/1M input, $15/1M output) via OpenRouter. Costs drop significantly if you apply the optimization techniques from our guide to cutting OpenClaw token costs.

Hosting Costs

Total Cost of Ownership

For a typical team bot deployment:

• Self-hosted route: $5-15/month (VPS) + $42/month (API) = $47-57/month
• ClawPod route: $29.9/month (hosting) + $42/month (API) = ~$72/month
• Local route: $0 (hosting) + $42/month (API) = $42/month (but no uptime guarantee)

Compare this to hiring a junior operations person ($3,000-5,000/month) or subscribing to a dedicated support bot platform ($200-500/month for similar capabilities). At under $75/month, an OpenClaw team bot is remarkably cost-effective.

For solopreneurs running leaner setups, check out how to run a one-person company with OpenClaw for under $300/month.

Why ClawPod Makes This Easier

The hardest part of deploying an OpenClaw Discord or Slack bot is not the bot configuration — it is the infrastructure. You need:

• A server that is always online (your laptop going to sleep kills the bot)
• A public IP address or domain name
• A valid SSL certificate (Slack requires HTTPS for webhooks)
• Firewall rules that allow incoming webhook traffic
• Monitoring to know when the bot goes down
• Regular updates to keep OpenClaw patched

ClawPod handles all of this for $29.9/month. You get:

• A dedicated OpenClaw instance running 24/7 on managed infrastructure
• Automatic SSL certificates (no Let's Encrypt renewal headaches)
• Pre-configured webhook endpoints ready for Discord and Slack
• A management dashboard with uptime monitoring and alerts
• One-click updates when new OpenClaw versions are released

If your time is worth more than $10/hour — and it is — the hours you save not debugging SSL certificates and Docker networking pay for the subscription several times over.

Multi-Platform Setup: Running Discord and Slack Simultaneously

Many teams use both platforms — Discord for community and Slack for internal work. OpenClaw supports both simultaneously:

messaging:
  discord:
    enabled: true
    token: '${DISCORD_BOT_TOKEN}'
    allowed_channels:
      - 'community-support'
      - 'general'
    thread_mode: true

  slack:
    enabled: true
    bot_token: '${SLACK_BOT_TOKEN}'
    signing_secret: '${SLACK_SIGNING_SECRET}'
    allowed_channels:
      - 'engineering'
      - 'support-internal'
    response_type: 'thread'

Both integrations share the same OpenClaw instance, the same AI model, and the same knowledge base — but they operate independently. A question asked in Discord does not appear in Slack, and vice versa. The bot maintains separate conversation contexts for each platform and each channel.

This is particularly powerful for companies that use Discord for public community support and Slack for internal operations. One OpenClaw instance, two audiences, consistent answers.

Frequently Asked Questions

Can OpenClaw work with both Discord and Slack at the same time?

Yes. OpenClaw supports multiple messaging platforms simultaneously from a single instance. You configure each platform separately in the config file, and they operate independently — separate conversations, separate channel permissions, shared knowledge base and AI model. There is no performance penalty for running both.

Does my OpenClaw instance need to be publicly accessible for Discord and Slack bots?

For Slack webhooks, yes — Slack sends HTTP requests to your server, which requires a public URL with SSL. For Discord, it depends on the connection method: webhook mode requires a public URL, but the default gateway mode (WebSocket) works behind firewalls because your server initiates the connection outward. If public access is a problem, use ClawPod which provides SSL and public endpoints automatically, or use Slack's Socket Mode as an alternative.

How do I keep my Discord and Slack bot tokens secure?

Never hardcode tokens in config files. Use environment variables or a secrets manager (like Docker secrets or HashiCorp Vault). Rotate tokens every 90 days. Use separate bot apps for development and production. Monitor for unexpected bot activity. Our security guide covers this in detail.

How much does it cost to run an OpenClaw team bot?

For a 10-person team with moderate usage (100-150 messages/day), expect $40-50/month in API costs using Claude Sonnet 4. Hosting adds $5-30/month depending on whether you self-host or use managed hosting. Total: $50-80/month. That is roughly 1-2% of what equivalent human help would cost. See our cost optimization guide for techniques to reduce API spending by up to 80%.

What are the best use cases for an OpenClaw Discord or Slack bot?

The highest-ROI use cases are: (1) knowledge base Q&A that saves your team from searching through documentation, (2) automated daily standups that replace synchronous meetings, (3) ticket triage that routes issues to the right team instantly, (4) meeting summaries with auto-extracted action items, and (5) incident response coordination. For more real-world examples, see our OpenClaw use cases guide.

If you are exploring what else OpenClaw can automate for your business, check out our guides on real-world use cases, running a one-person company, and security best practices.

Ready to deploy a team bot without the infrastructure headaches? ClawPod gives you a managed OpenClaw instance with SSL, monitoring, and pre-configured webhook endpoints — ready for Discord and Slack in minutes. Start your bot at $29.9/month.