discord-bot

Original source / Raw SKILL.md

---
name: discord-bot
description: "Discord Bot API integration — manage servers, channels, messages, roles, members, and webhooks via the Discord REST API. Send messages, manage server settings, moderate users, create channels, and handle role assignments. Built for AI agents — Python stdlib only, zero dependencies. Use for Discord server management, bot automation, community management, message sending, moderation, and webhook integrations."
homepage: https://www.agxntsix.ai
license: MIT
compatibility: Python 3.10+ (stdlib only — no dependencies)
metadata: {"openclaw": {"emoji": "🤖", "requires": {"env": ["DISCORD_BOT_TOKEN"]}, "primaryEnv": "DISCORD_BOT_TOKEN", "homepage": "https://www.agxntsix.ai"}}
---

# 🤖 Discord Bot

Discord Bot API integration — manage servers, channels, messages, roles, members, and webhooks via the Discord REST API.

## Features

- **Send messages** — text, embeds, files to any channel
- **Channel management** — create, update, delete channels
- **Server info** — guild details, settings, and statistics
- **Member management** — list, kick, ban, role assignment
- **Role management** — create, update, assign roles
- **Message operations** — send, edit, delete, react, pin
- **Webhook management** — create and send via webhooks
- **Thread management** — create and manage threads
- **Emoji management** — list and manage custom emojis
- **Audit log** — view server audit events

## Requirements

| Variable | Required | Description |
|----------|----------|-------------|
| `DISCORD_BOT_TOKEN` | ✅ | API key/token for Discord Bot |

## Quick Start

```bash
# List bot's servers
python3 {baseDir}/scripts/discord-bot.py guilds
```

```bash
# Get server details
python3 {baseDir}/scripts/discord-bot.py guild-get 123456789
```

```bash
# List server channels
python3 {baseDir}/scripts/discord-bot.py channels --guild 123456789
```

```bash
# Create a channel
python3 {baseDir}/scripts/discord-bot.py channel-create --guild 123456789 "general-chat" --type text
```



## Commands

### `guilds`
List bot's servers.
```bash
python3 {baseDir}/scripts/discord-bot.py guilds
```

### `guild-get`
Get server details.
```bash
python3 {baseDir}/scripts/discord-bot.py guild-get 123456789
```

### `channels`
List server channels.
```bash
python3 {baseDir}/scripts/discord-bot.py channels --guild 123456789
```

### `channel-create`
Create a channel.
```bash
python3 {baseDir}/scripts/discord-bot.py channel-create --guild 123456789 "general-chat" --type text
```

### `channel-update`
Update channel.
```bash
python3 {baseDir}/scripts/discord-bot.py channel-update 987654321 '{"name":"announcements","topic":"Important updates"}'
```

### `send`
Send a message.
```bash
python3 {baseDir}/scripts/discord-bot.py send --channel 987654321 "Hello from the bot!"
```

### `send-embed`
Send embed message.
```bash
python3 {baseDir}/scripts/discord-bot.py send-embed --channel 987654321 '{"title":"Update","description":"New feature released","color":5814783}'
```

### `messages`
List channel messages.
```bash
python3 {baseDir}/scripts/discord-bot.py messages --channel 987654321 --limit 20
```

### `message-edit`
Edit a message.
```bash
python3 {baseDir}/scripts/discord-bot.py message-edit --channel 987654321 --message 111222333 "Updated text"
```

### `message-delete`
Delete a message.
```bash
python3 {baseDir}/scripts/discord-bot.py message-delete --channel 987654321 --message 111222333
```

### `react`
Add reaction to message.
```bash
python3 {baseDir}/scripts/discord-bot.py react --channel 987654321 --message 111222333 --emoji 👍
```

### `members`
List server members.
```bash
python3 {baseDir}/scripts/discord-bot.py members --guild 123456789 --limit 50
```

### `roles`
List server roles.
```bash
python3 {baseDir}/scripts/discord-bot.py roles --guild 123456789
```

### `role-assign`
Assign role to member.
```bash
python3 {baseDir}/scripts/discord-bot.py role-assign --guild 123456789 --user 444555666 --role 777888999
```

### `webhooks`
List channel webhooks.
```bash
python3 {baseDir}/scripts/discord-bot.py webhooks --channel 987654321
```


## Output Format

All commands output JSON by default. Add `--human` for readable formatted output.

```bash
# JSON (default, for programmatic use)
python3 {baseDir}/scripts/discord-bot.py guilds --limit 5

# Human-readable
python3 {baseDir}/scripts/discord-bot.py guilds --limit 5 --human
```

## Script Reference

| Script | Description |
|--------|-------------|
| `{baseDir}/scripts/discord-bot.py` | Main CLI — all Discord Bot operations |

## Data Policy

This skill **never stores data locally**. All requests go directly to the Discord Bot API and results are returned to stdout. Your data stays on Discord Bot servers.

## Credits
---
Built by [M. Abidi](https://www.linkedin.com/in/mohammad-ali-abidi) | [agxntsix.ai](https://www.agxntsix.ai)
[YouTube](https://youtube.com/@aiwithabidi) | [GitHub](https://github.com/aiwithabidi)
Part of the **AgxntSix Skill Suite** for OpenClaw agents.

📅 **Need help setting up OpenClaw for your business?** [Book a free consultation](https://cal.com/agxntsix/abidi-openclaw)


---

## Skill Companion Files

> Additional files collected from the skill directory layout.

### _meta.json

```json
{
  "owner": "aiwithabidi",
  "slug": "discord-bot",
  "displayName": "Discord Bot",
  "latest": {
    "version": "1.0.0",
    "publishedAt": 1772578366862,
    "commit": "https://github.com/openclaw/skills/commit/ffd692a8ec8ddaba94776ecfc84e0d2407e28eca"
  },
  "history": []
}

```

### scripts/discord-bot.py

```python
#!/usr/bin/env python3
"""Discord Bot CLI — comprehensive API integration for AI agents.

Full CRUD operations, search, reporting, and automation.
Zero dependencies beyond Python stdlib.
"""

import argparse
import json
import os
import sys
import urllib.request
import urllib.error
import urllib.parse
from datetime import datetime, timezone

API_BASE = "https://discord.com/api/v10"


def get_token():
    """Get API token from environment."""
    token = os.environ.get("DISCORD_BOT_TOKEN", "")
    if not token:
        env_path = os.path.join(
            os.environ.get("WORKSPACE", os.path.expanduser("~/.openclaw/workspace")),
            ".env"
        )
        if os.path.exists(env_path):
            with open(env_path) as f:
                for line in f:
                    line = line.strip()
                    if line.startswith("DISCORD_BOT_TOKEN="):
                        token = line.split("=", 1)[1].strip().strip('"').strip("'")
                        break
    if not token:
        print(f"Error: DISCORD_BOT_TOKEN not set", file=sys.stderr)
        sys.exit(1)
    return token


def api(method, path, data=None, params=None):
    """Make an API request."""
    token = get_token()
    url = f"{API_BASE}{path}"
    if params:
        qs = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
        if qs:
            url = f"{url}?{qs}"
    body = json.dumps(data).encode() if data else None
    req = urllib.request.Request(url, data=body, method=method)
    req.add_header("Authorization", f"Bearer {token}")
    req.add_header("Content-Type", "application/json")
    req.add_header("Accept", "application/json")
    try:
        resp = urllib.request.urlopen(req, timeout=30)
        raw = resp.read().decode()
        return json.loads(raw) if raw.strip() else {"ok": True}
    except urllib.error.HTTPError as e:
        err_body = e.read().decode()
        print(json.dumps({"error": True, "code": e.code, "message": err_body}), file=sys.stderr)
        sys.exit(1)


def output(data, human=False):
    """Output data as JSON or human-readable."""
    if human and isinstance(data, list):
        for item in data:
            if isinstance(item, dict):
                for k, v in item.items():
                    print(f"  {k}: {v}")
                print()
            else:
                print(item)
    elif human and isinstance(data, dict):
        for k, v in data.items():
            print(f"  {k}: {v}")
    else:
        print(json.dumps(data, indent=2, default=str))


def cmd_guilds(args):
    """List bot's servers."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/guilds/{args.id}")
    else:
        data = api("GET", "/guilds", params=params)
    output(data, getattr(args, 'human', False))

def cmd_guild_get(args):
    """Get server details."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/guild/{args.id}")
    else:
        data = api("GET", "/guild/get", params=params)
    output(data, getattr(args, 'human', False))

def cmd_channels(args):
    """List server channels."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/channels/{args.id}")
    else:
        data = api("GET", "/channels", params=params)
    output(data, getattr(args, 'human', False))

def cmd_channel_create(args):
    """Create a channel."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("POST", f"/channel/{args.id}")
    else:
        data = api("POST", "/channel/create", params=params)
    output(data, getattr(args, 'human', False))

def cmd_channel_update(args):
    """Update channel."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("PUT", f"/channel/{args.id}")
    else:
        data = api("PUT", "/channel/update", params=params)
    output(data, getattr(args, 'human', False))

def cmd_send(args):
    """Send a message."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("POST", f"/send/{args.id}")
    else:
        data = api("POST", "/send", params=params)
    output(data, getattr(args, 'human', False))

def cmd_send_embed(args):
    """Send embed message."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("POST", f"/send/{args.id}")
    else:
        data = api("POST", "/send/embed", params=params)
    output(data, getattr(args, 'human', False))

def cmd_messages(args):
    """List channel messages."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/messages/{args.id}")
    else:
        data = api("GET", "/messages", params=params)
    output(data, getattr(args, 'human', False))

def cmd_message_edit(args):
    """Edit a message."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/message/{args.id}")
    else:
        data = api("GET", "/message/edit", params=params)
    output(data, getattr(args, 'human', False))

def cmd_message_delete(args):
    """Delete a message."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("DELETE", f"/message/{args.id}")
    else:
        data = api("DELETE", "/message/delete", params=params)
    output(data, getattr(args, 'human', False))

def cmd_react(args):
    """Add reaction to message."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/react/{args.id}")
    else:
        data = api("GET", "/react", params=params)
    output(data, getattr(args, 'human', False))

def cmd_members(args):
    """List server members."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/members/{args.id}")
    else:
        data = api("GET", "/members", params=params)
    output(data, getattr(args, 'human', False))

def cmd_roles(args):
    """List server roles."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/roles/{args.id}")
    else:
        data = api("GET", "/roles", params=params)
    output(data, getattr(args, 'human', False))

def cmd_role_assign(args):
    """Assign role to member."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/role/{args.id}")
    else:
        data = api("GET", "/role/assign", params=params)
    output(data, getattr(args, 'human', False))

def cmd_webhooks(args):
    """List channel webhooks."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/webhooks/{args.id}")
    else:
        data = api("GET", "/webhooks", params=params)
    output(data, getattr(args, 'human', False))


COMMANDS = {
    "guilds": cmd_guilds,
    "guild-get": cmd_guild_get,
    "channels": cmd_channels,
    "channel-create": cmd_channel_create,
    "channel-update": cmd_channel_update,
    "send": cmd_send,
    "send-embed": cmd_send_embed,
    "messages": cmd_messages,
    "message-edit": cmd_message_edit,
    "message-delete": cmd_message_delete,
    "react": cmd_react,
    "members": cmd_members,
    "roles": cmd_roles,
    "role-assign": cmd_role_assign,
    "webhooks": cmd_webhooks,
}


def main():
    parser = argparse.ArgumentParser(
        description="Discord Bot CLI — AI agent integration",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("command", choices=list(COMMANDS.keys()), help="Command to run")
    parser.add_argument("args", nargs="*", help="Command arguments")
    parser.add_argument("--human", action="store_true", help="Human-readable output")
    parser.add_argument("--limit", type=int, help="Limit results")
    parser.add_argument("--id", help="Resource ID")
    parser.add_argument("--from", dest="from_date", help="Start date")
    parser.add_argument("--to", dest="to_date", help="End date")
    parser.add_argument("--status", help="Filter by status")
    parser.add_argument("--sort", help="Sort field")
    parser.add_argument("--query", help="Search query")

    parsed = parser.parse_args()
    cmd_func = COMMANDS[parsed.command]
    cmd_func(parsed)


if __name__ == "__main__":
    main()

```