How to Set Up OpenClaw in Slack in Under 5 Minutes

Two Paths, Same Destination

Getting OpenClaw into your Slack workspace can take five minutes or five days, depending on which path you choose. Neither path is wrong — they involve different trade-offs around control, effort, and ongoing maintenance.

This guide walks through both approaches in detail. The DIY self-hosted route gives you maximum control and customization. The managed route via SlackClaw gives you maximum speed and minimal ops burden. We'll be honest about the advantages and limitations of each so you can make the right call for your team.

Path 1: Self-Hosted Setup (The DIY Route)

Self-hosting OpenClaw for Slack gives you complete control over the infrastructure, the agent configuration, and the data. It's the right choice for teams with strong DevOps capabilities who want full ownership of their AI agent deployment.

Here's the realistic step-by-step.

Prerequisites

Before you begin, make sure you have:

• A server or container environment with at least 4 GB RAM (AWS EC2 t3.medium or equivalent)
• PostgreSQL 14+ installed or available as a managed service
• Redis 7+ installed or available as a managed service
• Node.js 20+ or Python 3.11+ (depending on which OpenClaw runtime you prefer)
• A domain name with DNS access (for SSL and webhook endpoints)
• Admin access to your Slack workspace
• An API key from your preferred LLM provider (OpenAI, Anthropic, etc.)

Step 1: Provision Your Infrastructure

Spin up your compute instance and make sure your database and Redis instances are accessible. If you're using AWS, a typical setup involves an EC2 instance, an RDS PostgreSQL instance, and an ElastiCache Redis cluster. For simplicity, you can run all three on a single machine during initial testing.

# Example: Launch an EC2 instance with Ubuntu 22.04
# Then install dependencies
sudo apt update && sudo apt install -y nodejs npm postgresql redis-server nginx certbot

Step 2: Clone and Configure OpenClaw

git clone https://github.com/openclaw/openclaw.git
cd openclaw
npm install

Copy the environment template and fill in your configuration:

cp .env.example .env

You'll need to set at minimum:

# .env configuration
DATABASE_URL=postgresql://user:pass@localhost:5432/openclaw
REDIS_URL=redis://localhost:6379
LLM_PROVIDER=anthropic
LLM_API_KEY=sk-ant-...
SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...
SLACK_SIGNING_SECRET=...
PORT=3000

Step 3: Create a Slack App

This is where many teams hit their first snag. Head to api.slack.com/apps and create a new app. You'll need to:

1. Create the app from a manifest or from scratch
2. Configure bot token scopes: chat:write, channels:history, channels:read, groups:read, groups:history, im:history, im:read, im:write, users:read, app_mentions:read, files:read
3. Enable Event Subscriptions and subscribe to: message.channels, message.groups, message.im, app_mention
4. Set the Request URL for event subscriptions to your server's endpoint (requires SSL — see step 5)
5. Enable Socket Mode if you want to avoid exposing a public webhook endpoint
6. Install the app to your workspace and collect the Bot User OAuth Token and App-Level Token

Getting the OAuth scopes right is critical. Missing a scope means the agent silently fails on certain operations, which is frustrating to debug.

Step 4: Initialize the Database

# Create the database
createdb openclaw

# Run migrations
npm run db:migrate

# Seed initial configuration
npm run db:seed

Step 5: Set Up SSL and Reverse Proxy

Slack requires HTTPS for event subscription endpoints. Set up nginx as a reverse proxy with Let's Encrypt SSL:

# Configure nginx
sudo nano /etc/nginx/sites-available/openclaw

# Example nginx configuration
server {
    server_name your-domain.com;
    
    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

# Get SSL certificate
sudo certbot --nginx -d your-domain.com

Step 6: Configure Integrations

For each tool you want the agent to access (GitHub, Jira, Linear, Notion, etc.), you'll need to:

1. Create an OAuth app or generate an API token in the target service
2. Configure the credentials in OpenClaw's integration settings
3. Test the connection

Repeat this for every integration. With 5-10 tools, this step alone can take an hour or more. Learn more about our pricing page.

Step 7: Start the Agent and Test

# Start in production mode
NODE_ENV=production npm start

# Or use pm2 for process management
pm2 start npm --name openclaw -- start

Go to your Slack workspace, mention the bot in a channel, and verify it responds. Then test each integration by asking the agent to perform an action in each connected tool. Learn more about our security features.

Step 8: Set Up Monitoring

For a production deployment, you'll want:

• Health check endpoints monitored by an external service (UptimeRobot, Pingdom, etc.)
• Log aggregation (CloudWatch, Datadog, or a self-hosted ELK stack)
• Error alerting (PagerDuty, Opsgenie, or at minimum email alerts)
• Database backup automation
• SSL certificate auto-renewal verification

Total realistic time: 4-8 hours for an experienced engineer, 2-5 days for a team setting this up for the first time.

Path 2: Managed Setup via SlackClaw (The Fast Route)

If the self-hosted path seems like more infrastructure work than your team wants to take on, the managed route gets you to the same destination with significantly less effort.

Step 1: Install SlackClaw

Go to the Slack App Directory, search for SlackClaw, and click Install. Authorize the app for your workspace when prompted. This takes about 30 seconds.

Behind the scenes, this provisions a dedicated server instance for your team. Your data is isolated — not shared with other workspaces.

Step 2: Connect Your Tools

Open the SlackClaw dashboard (linked in the welcome DM the bot sends you). You'll see a grid of 800+ available integrations. Click any tool to connect it via OAuth — a single click and authorization flow for each.

Common first connections:

• GitHub or GitLab — for PR monitoring, issue management, and code-related workflows
• Linear or Jira — for sprint management and ticket coordination
• Notion or Confluence — for documentation access and updates
• Gmail or Outlook — for email-related automations
• Google Calendar — for meeting prep and scheduling

Each OAuth connection takes about 15 seconds. Connecting 5 tools takes about two minutes.

Step 3: Start Using the Agent

That's it. Head to any Slack channel where the bot has been added, mention it, and start working. No database setup, no SSL configuration, no integration debugging.

Total realistic time: Under 5 minutes.

Your First Workflow (Either Path)

Regardless of which setup path you chose, the first thing to do is build a workflow that delivers immediate, visible value to your team. Here are three starter workflows that work well.

Daily Standup Digest

Ask your agent to post a daily summary to your team channel:

@agent Set up a daily standup digest for #engineering at 9am:
- Open PRs from GitHub that need review
- Current sprint items from Linear with status updates
- Any high-priority Jira tickets updated in the last 24 hours
Format it as a clean summary with bullet points.

The agent will create a scheduled skill that runs every weekday morning, pulling live data from your connected tools.

PR Review Reminders

@agent Monitor our GitHub repos for open PRs older than 24 hours.
When you find one, DM the assigned reviewer with a friendly reminder
and link to the PR. Check every 4 hours during business hours.

Support Ticket Triage

@agent Watch for new emails in our support@company.com inbox.
Classify each one by urgency (P0-P3) and topic.
Create a Linear ticket for P0 and P1 issues automatically.
Post a summary to #support-triage for everything else.

Seeding Your Agent's Memory

One of the most impactful things you can do in your first session — on either deployment path — is seed the agent's persistent memory with your team's context. Spend 10 minutes telling the agent about your team: For related insights, see OpenClaw for Slack Teams: The Complete 2026 Guide.

@agent Here's some context about our team:

- We're a 12-person engineering team working on a B2B SaaS product
- Our sprint cadence is 2 weeks, starting on Mondays
- We use Linear for project management, GitHub for code, Notion for docs
- "P0" means drop everything — customer-facing outage or data loss
- "Ship it" means the PR is approved and should be merged immediately
- Our team channels: #engineering (general), #incidents (P0s), #deploys
- The PM is Sarah, the engineering lead is Marcus
- We prefer bullet-point summaries over long paragraphs

This context gets stored in the agent's persistent memory and is applied to every future interaction. The more specific you are, the more useful the agent becomes from day one.

Side-by-Side Setup Comparison

Step	Self-Hosted	SlackClaw (Managed)
Provision infrastructure	Manual (EC2, RDS, Redis, nginx)	Automatic
Install OpenClaw	git clone + npm install + configuration	One-click Slack App install
Configure Slack App	Manual (OAuth scopes, events, tokens — 6+ sub-steps)	Pre-configured
Set up database	Create DB, run migrations, seed	Automatic
Configure SSL	nginx + Let's Encrypt + domain DNS	Not needed
Connect integrations	Manual per tool (OAuth apps, API keys)	One-click OAuth per tool
Set up monitoring	Manual (health checks, logging, alerts)	Included
Total steps	15-20+	3
Total time	4-8 hours (experienced) to 2-5 days (learning curve)	Under 5 minutes

Common Setup Issues (Self-Hosted)

If you go the self-hosted route, here are the issues that trip up most teams:

Slack OAuth Scope Misconfiguration

The most common problem. If the agent can read messages but can't post responses, you're probably missing the chat:write scope. If it can't read channel history, check channels:history and groups:history. Each missing scope causes a different silent failure, and the error messages aren't always clear about which scope is needed.

SSL Certificate Issues

Slack won't send events to non-HTTPS endpoints. If your Let's Encrypt certificate isn't set up correctly, or if it expires (they last 90 days), your agent will stop receiving messages without any obvious error on the Slack side. Set up auto-renewal and verify it works.

Database Connection Pooling

Under moderate load, you may exhaust database connections if you haven't configured connection pooling. Use PgBouncer or your database provider's built-in pooling. The default PostgreSQL connection limit of 100 is often too low for a busy agent.

Memory Management

OpenClaw's persistent memory layer can grow large over time. Configure retention policies to archive or prune old conversation data. Without this, your database will grow unbounded and eventually impact query performance. For related insights, see OpenClaw API: Extending Your Slack Agent Programmatically.

What to Do After Setup

Whether you took five minutes or five days to get here, the setup is the beginning — not the end. The value of an OpenClaw agent in Slack compounds over time as you:

• Build custom skills tailored to your team's workflows
• Connect more tools as new use cases emerge
• Let the agent's persistent memory accumulate context about your team
• Share useful prompts and workflows with teammates

The teams that get the most from OpenClaw in Slack are the ones that treat it as a living system — something they iterate on regularly, not something they set up once and forget about.

Start with one workflow. Prove it works. Build from there.