OpenClaw Integrations: Connect Notion, Slack, GitHub & 10+ Tools

Why Integrations Matter for AI Agents

An AI agent in isolation can answer questions and generate text. But an AI agent connected to your tools can actually do work. It can check your Notion project board, draft a status update, post it to Slack, and create a GitHub issue for the blocked task it found — all without you opening four browser tabs.

OpenClaw separates integrations into two categories: channels and tools. Channels are where your agent communicates — Telegram, Slack, Discord, email. Tools are what your agent uses to get work done — Notion, GitHub, Google Calendar, webhooks. A well-configured agent uses both: it listens on Slack (channel) and pulls project data from Notion (tool) to answer your questions.

Every integration in OpenClaw follows the same pattern: set a configuration value with openclaw config set, define how your agent should use it in SOUL.md, and restart the gateway. No code changes. No separate deployments. No plugin marketplaces.

How OpenClaw Integrations Work

Under the hood, OpenClaw's integration system has three layers:

# Full integration setup pattern:

# 1. Set the credential
openclaw config set integrations.notion.apikey ntn_YOUR_KEY

# 2. Define the skill in SOUL.md
# ## Tools — USE THEM
# - Use Notion to read project docs and task boards

# 3. Restart the gateway
openclaw gateway restart

Telegram Integration

Telegram is the most popular channel for OpenClaw agents. It gives you mobile access to any agent, supports group chats for team interaction, and requires no server infrastructure — OpenClaw uses Telegram's long polling, so it works behind firewalls without a public URL.

Step-by-Step Setup

# Set the bot token
openclaw config set channels.telegram.bottoken YOUR_TOKEN

# Optionally restrict to a specific chat
openclaw config set channels.telegram.chatid YOUR_CHAT_ID

# Restart to activate
openclaw gateway restart

# Check that Telegram is connected
openclaw channels status

# Expected output:
# telegram: connected (bot: @YourBotName)
# web: running (localhost:18789)

Telegram Group Chats

Add your bot to any Telegram group to give the whole team access. By default, the agent responds to every message. To make it respond only when mentioned, configure privacy mode through BotFather with /setprivacy and set it to Enabled.

Slack Integration

Slack is the strongest channel integration for teams. Your agent appears as a Slack app that responds to mentions, handles direct messages, and replies in threads to keep conversations organized.

Creating the Slack App

chat:write          # Send messages
app_mentions:read   # Respond to @mentions
channels:history    # Read public channel messages
im:history          # Read direct messages
im:write            # Send direct messages
groups:history      # Read private channel messages

# Expose your local gateway
ngrok http 18789

# Use the ngrok URL as your Request URL:
# https://abc123.ngrok.io/channels/slack/events

# Subscribe to bot events:
#   app_mention
#   message.im

# Set the Slack bot token
openclaw config set channels.slack.bottoken xoxb-YOUR-SLACK-TOKEN

# Optionally set a default channel
openclaw config set channels.slack.channel general

# Restart the gateway
openclaw gateway restart

Slash Commands

You can register custom slash commands in your Slack app settings to trigger specific agent actions. Point each slash command URL to https://your-domain/channels/slack/commands. The agent receives the command text as a message and responds in the channel. Common setups include /ask for questions, /report for status updates, and /draft for content generation.

Notion Integration

Notion is one of the most powerful tool integrations in OpenClaw. Your agent can read pages, query databases, create new entries, and use your Notion workspace as a living knowledge base. This turns your agent from a generic chatbot into a context-aware assistant that knows your projects.

Setting Up the Notion API

# Set the Notion API key
openclaw config set integrations.notion.apikey ntn_YOUR_SECRET

# Optionally set a default database ID
openclaw config set integrations.notion.database YOUR_DATABASE_ID

# Restart the gateway
openclaw gateway restart

SOUL.md Skills for Notion

The configuration gives your agent access to Notion. The SOUL.md tells it how to use that access:

## Tools — USE THEM
- Use Notion to look up project requirements before
  starting any task
- Use Notion to check the content calendar for deadlines
- When you finish a draft, create a new Notion page in
  the "Content Drafts" database with the full text
- Use Notion database queries to find tasks assigned to
  the current user

## Knowledge Base
- Project wiki: Notion page ID 30408b1c-xxxx-xxxx
- Content calendar: Notion database ID abc123-xxxx
- Style guide: Notion page ID def456-xxxx

Agents with Notion access are particularly effective as project managers (reading task boards), content writers (checking editorial calendars), and research assistants (pulling from documentation wikis).

GitHub Integration

Connect your OpenClaw agent to GitHub to automate code reviews, manage issues, monitor pull requests, and get CI/CD status updates — all through natural language.

Personal Access Token Setup

# Set the GitHub personal access token
openclaw config set integrations.github.token ghp_YOUR_TOKEN

# Set the repositories the agent can access
openclaw config set integrations.github.repos "owner/repo-name"

# For multiple repos, use comma-separated values
openclaw config set integrations.github.repos "owner/repo1,owner/repo2"

# Restart the gateway
openclaw gateway restart

Automated PR Reviews

One of the most valuable GitHub integrations is automated pull request reviews. Set up a webhook in your GitHub repository pointing to your gateway, and the agent reviews every new PR automatically:

# In your GitHub repo Settings > Webhooks:
# Payload URL: https://your-domain/webhooks/github
# Content type: application/json
# Secret: your-webhook-secret
# Events: Pull requests

# Configure the webhook secret in OpenClaw
openclaw config set integrations.github.webhook_secret YOUR_SECRET

# SOUL.md skill for code reviews:
## Tools — USE THEM
- When a new PR is opened, review the diff for:
  1. Security vulnerabilities
  2. Performance issues
  3. Code style violations
  4. Missing tests
- Post your review as a GitHub PR comment
- Flag critical issues as "Request Changes"
- Approve clean PRs with a summary of what was checked

Issue Management

Your agent can also create, update, and close GitHub issues. This is powerful for project management agents that track work across Notion and GitHub simultaneously:

# Ask your agent to create issues via Slack or Telegram
> "Create a GitHub issue for the login page bug
>  that John reported yesterday"

# The agent creates an issue with:
# - Title extracted from context
# - Description with reproduction steps
# - Labels assigned based on keywords
# - Assignee set if mentioned

Discord Integration

Discord is ideal for community-facing agents, gaming teams, and developer communities. Your agent joins as a bot user and can respond to messages, react to mentions, and handle slash commands.

Bot Setup and Configuration

# Set the Discord bot token
openclaw config set channels.discord.bottoken YOUR_DISCORD_TOKEN

# Optionally restrict to specific server
openclaw config set channels.discord.guildid YOUR_GUILD_ID

# Optionally restrict to specific channels
openclaw config set channels.discord.channels "general,support"

# Restart the gateway
openclaw gateway restart

Your agent now responds to messages in the configured channels. For a more polished experience, register slash commands through the Discord Developer Portal (e.g., /ask, /status) that route to your gateway.

Email Integration

Email integration allows your agent to receive emails and send responses, making it useful for customer support, lead qualification, and automated follow-ups. OpenClaw supports both SMTP for sending and webhook-based receiving.

SMTP Configuration

# Configure SMTP for sending emails
openclaw config set integrations.email.smtp.host smtp.gmail.com
openclaw config set integrations.email.smtp.port 587
openclaw config set integrations.email.smtp.user your-agent@gmail.com
openclaw config set integrations.email.smtp.pass YOUR_APP_PASSWORD

# Configure the sender name
openclaw config set integrations.email.from.name "Project Manager Agent"
openclaw config set integrations.email.from.address your-agent@gmail.com

# For receiving, set up a forwarding webhook
openclaw config set integrations.email.webhook.path /webhooks/email

# Restart the gateway
openclaw gateway restart

For receiving emails, use a service like Mailgun, SendGrid, or Postmark that supports inbound email parsing. Configure their webhook to point at your gateway's email endpoint: https://your-domain/webhooks/email. The agent receives the email content as a message and can reply through SMTP.

Webhook Integration

Webhooks are OpenClaw's most flexible integration point. Any service that can send or receive HTTP requests can integrate with your agent. This is how you connect tools that do not have native OpenClaw support.

Incoming Webhooks

Incoming webhooks let external services send events to your agent. The agent receives the webhook payload as context and can take action based on it:

# Configure the webhook secret for verification
openclaw config set integrations.webhook.secret YOUR_WEBHOOK_SECRET

# Set which agent handles incoming webhooks
openclaw config set integrations.webhook.agent pm

# Restart the gateway
openclaw gateway restart

# Your webhook endpoint is now available at:
# POST http://localhost:18789/webhooks/incoming
#
# Headers:
#   Content-Type: application/json
#   X-Webhook-Secret: YOUR_WEBHOOK_SECRET
#
# Body: any JSON payload

Outgoing Webhooks via SOUL.md

Your agent can also call external APIs as a tool. Define webhook targets in your SOUL.md:

## Tools — USE THEM
- Use HTTP requests to send alerts to
  https://hooks.slack.com/services/T00/B00/xxxx
  when a critical issue is detected
- POST to https://api.example.com/events
  with a summary when a weekly report is complete
- Call the internal API at http://localhost:3000/api/notify
  to trigger downstream workflows

REST API Access

OpenClaw also exposes a REST API on the gateway that lets you interact with agents programmatically:

# Send a message to an agent via REST API
curl -X POST http://localhost:18789/api/agent/pm/message \
  -H "Content-Type: application/json" \
  -d '{"message": "What is the status of the Q1 roadmap?"}'

# List all agents
curl http://localhost:18789/api/agents

# Get agent status
curl http://localhost:18789/api/agent/pm/status

Google Calendar and Google Sheets

Google Workspace integrations give your agent access to scheduling and spreadsheet data. These require a Google service account or OAuth credentials.

Google Calendar

# Set Google service account credentials
openclaw config set integrations.google.credentials /path/to/service-account.json

# Set the calendar ID
openclaw config set integrations.google.calendar.id your-calendar@gmail.com

# Restart the gateway
openclaw gateway restart

# SOUL.md skill:
## Tools — USE THEM
- Check Google Calendar before scheduling meetings
- Create calendar events for content deadlines
- Send a daily summary of upcoming meetings at 8am

Google Sheets

# Uses the same service account as Calendar
openclaw config set integrations.google.credentials /path/to/service-account.json

# Set default spreadsheet
openclaw config set integrations.google.sheets.id YOUR_SPREADSHEET_ID

# Restart the gateway
openclaw gateway restart

# SOUL.md skill:
## Tools — USE THEM
- Read the "Content Tracker" Google Sheet to check
  which blog posts are in progress
- Update the "Status" column when a draft is complete
- Pull weekly metrics from the "Analytics" sheet
  for the Monday report

Share the Google Calendar and Google Sheets with your service account email (found in the service account JSON file) to grant the agent access.

Building Custom Integrations

OpenClaw's integration system is extensible. If the built-in integrations do not cover your use case, you can build custom channel handlers and tool integrations.

Custom Channel Handler

A custom channel handler listens for messages on a custom transport and routes them to your agent. Place your handler in the channels/ directory of your OpenClaw workspace:

# channels/custom-sms/handler.js
module.exports = {
  name: "custom-sms",

  // Called when the gateway starts
  async start(config, sendToAgent) {
    // Set up your listener (e.g., Twilio webhook)
    // When a message arrives, call:
    // sendToAgent(userId, messageText)
  },

  // Called when the agent responds
  async send(userId, response) {
    // Send the response back through your channel
    // e.g., Twilio API to send SMS
  }
};

# Register the custom channel
openclaw config set channels.custom-sms.enabled true
openclaw config set channels.custom-sms.handler channels/custom-sms/handler.js
openclaw gateway restart

Custom Tool Integration

For tools, the simplest approach is using webhooks combined with SOUL.md skills. For deeper integration, create a custom tool definition:

# tools/jira-integration/tool.json
{
  "name": "jira",
  "description": "Interact with Jira project management",
  "config": {
    "base_url": "https://your-company.atlassian.net",
    "auth_type": "api_token"
  },
  "actions": [
    "search_issues",
    "create_issue",
    "update_status",
    "get_sprint"
  ]
}

# Configure the tool
openclaw config set integrations.jira.url https://your-company.atlassian.net
openclaw config set integrations.jira.email your-email@company.com
openclaw config set integrations.jira.token YOUR_JIRA_API_TOKEN
openclaw gateway restart

Integration Comparison Table

Here is a side-by-side comparison of every OpenClaw integration to help you decide which ones to set up for your agents:

Start with one or two integrations and add more as your workflow demands. Telegram plus Notion is the most common pairing for solo users. Teams typically start with Slack plus GitHub.

Frequently Asked Questions