💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

Prologue — chat bots stopped being a toy and became infrastructure

Around 2018 a chat bot was "a fun side project." In 2026 it is different. Your company Slack is layered with alert bots, deploy bots, incident bots, and LLM assistants; your community Discord is layered with mod bots, role bots, ticket bots, and music bots; your KakaoTalk business channel is layered with support bots, booking bots, and payment bots. **Chat bots are no longer a tool — they are the first interface most users meet.**

Yet when you actually try to build one you get stuck. Slack bots want Bolt — but Bolt Node, Bolt Python, or Bolt Java? Discord bots want discord.js, but you cannot force a Python team onto Node — so Discord.py then? Wait, was Discord.py not deprecated in 2021? Then py-cord? nextcord? What about the Korean market — what does the KakaoTalk Channel API even look like? Japan is LINE Messaging API, but what if the Tokyo team insists on KARTE Talk Bot?

This post is the 2026 map of chat bot frameworks. Which platform, which language, which license, which survival prospects, and who should pick what for a company Slack bot, a community Discord, or a KakaoTalk business channel.

1. The 2026 chat bot framework map — by platform and language

Big picture first. Two axes: **platform** (Slack, Discord, Telegram, ...) and **language** (JS, Python, Java, Rust, ...).

| --- | --- | --- | --- | --- | --- |

Patterns that pop out:

1. **Slack unified on Bolt.** Node, Python, and Java all have official SDKs with nearly identical APIs. "Slack bot means Bolt" — done.

2. **Discord splits by language camp.** JS goes to discord.js, Python to discord.py/py-cord/nextcord, Java to JDA/Discord4J, Rust to serenity, .NET to DSharpPlus/Discord.Net. **Your team language comes first, library second.**

3. **Telegram also has a fork.** In Python, sync-flavored is python-telegram-bot; asyncio-native is aiogram. In Node, Telegraf is the de facto standard.

4. **WhatsApp, LINE, KakaoTalk are HTTP APIs.** Official SDKs are convenience layers; the substance is webhooks plus HTTP calls. Language dependence is light.

5. **Matrix, Mattermost, Rocket.Chat are the self-hosted camp.** Used for open-source / sovereignty-conscious messaging.

2. Slack Bolt — official Node/Python/Java, the unified company-bot standard

Slack's official bot framework is **Bolt**. The Node version landed in 2019; Python and Java followed, and all three are now first-class. Slack deliberately keeps the three SDK APIs parallel, so moving between languages costs little.

Bolt Node skeleton

const app = new App({

token: process.env.SLACK_BOT_TOKEN,

signingSecret: process.env.SLACK_SIGNING_SECRET,

socketMode: true,

appToken: process.env.SLACK_APP_TOKEN,

});

// Slash command

app.command('/hello', async ({ command, ack, respond }) => {

await ack();

await respond(`Hello, <@${command.user_id}>!`);

});

// Message event

app.message('help', async ({ message, say }) => {

await say('How can I help?');

});

// Interactive button

app.action('button_click', async ({ ack, body, respond }) => {

await ack();

await respond('Button was pressed');

});

(async () => {

await app.start();

console.log('Bolt app running');

})();

Bolt Python — same shape

from slack_bolt import App

from slack_bolt.adapter.socket_mode import SocketModeHandler

app = App(token=os.environ["SLACK_BOT_TOKEN"])

@app.command("/hello")

def handle_hello(ack, respond, command):

ack()

respond(f"Hello, <@{command['user_id']}>!")

@app.message("help")

def handle_help(message, say):

say("How can I help?")

@app.action("button_click")

def handle_button(ack, respond):

ack()

respond("Button was pressed")

if __name__ == "__main__":

SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"]).start()

The API shape is nearly identical: decorator names, parameter names, even the lifecycle.

Bolt Java — the enterprise side

public class SlackBotApp {

public static void main(String[] args) {

var config = new AppConfig();

config.setSigningSecret(System.getenv("SLACK_SIGNING_SECRET"));

config.setSingleTeamBotToken(System.getenv("SLACK_BOT_TOKEN"));

var app = new App(config);

app.command("/hello", (req, ctx) -> {

return ctx.ack("Hello, " + req.getPayload().getUserName() + "!");

});

var server = new com.slack.api.bolt.jetty.SlackAppServer(app);

try { server.start(); } catch (Exception e) { e.printStackTrace(); }

}

Socket Mode vs HTTP Mode

Bolt runs in two modes.

- **Socket Mode**: the bot makes an outbound WebSocket connection to Slack. No inbound ports, no public URL. Great for internal networks and small bots.

- **HTTP Mode**: Slack POSTs webhooks to your bot's URL. You need a public HTTPS endpoint. Better for production scale.

For a starting company bot, Socket Mode is overwhelmingly easier. Move to HTTP Mode once traffic justifies it.

Who picks which language

- **Company standard is Node**: Bolt Node. New Slack features tend to ship here first.

- **Company standard is Python (especially data teams)**: Bolt Python. Easy to share code with data / LLM pipelines.

- **Company standard is Java (large enterprise)**: Bolt Java. Spring integration is straightforward.

All three SDKs are maintained by the same vendor with very small feature lag. **Once you picked the language, you picked Bolt.**

3. discord.js — the Node.js Discord standard

The Node.js camp for Discord is effectively monopolized by **discord.js**. v14 stabilized in mid-2025, v15 is in active development as of 2026. Slash commands, buttons, select menus, modals, threads, forum channels, automod — almost every new Discord feature lands here quickly.

Minimal skeleton

const client = new Client({

intents: [

GatewayIntentBits.Guilds,

GatewayIntentBits.GuildMessages,

GatewayIntentBits.MessageContent,

});

client.once('ready', () => {

console.log(`Logged in as ${client.user?.tag}`);

});

// Register a slash command

const ping = new SlashCommandBuilder()

.setName('ping')

.setDescription('Measure latency');

client.on('interactionCreate', async (interaction) => {

if (!interaction.isChatInputCommand()) return;

if (interaction.commandName === 'ping') {

const ms = Date.now() - interaction.createdTimestamp;

await interaction.reply(`Pong (${ms}ms)`);

}

});

client.login(process.env.DISCORD_TOKEN);

Intents — the permission model

Discord requires you to declare which events your bot wants. **MessageContent intent** became a privileged intent in 2022; bots in more than 100 servers need explicit Discord approval. Small bots are auto-approved.

Sharding — running large bots

Once a bot crosses 2500 servers, Discord requires sharding. discord.js ships `ShardingManager` so you can spin up shards as separate processes.

const manager = new ShardingManager('./bot.js', {

totalShards: 'auto',

token: process.env.DISCORD_TOKEN,

});

manager.on('shardCreate', (shard) => console.log(`Shard ${shard.id} started`));

manager.spawn();

Why discord.js won

- **TypeScript first-class**: v14 onward, the types are extremely precise.

- **First-class Discord feature support**: API changes are usually reflected within days.

- **Massive ecosystem**: boilerplates, CLI generators, cog-style frameworks, DB adapters.

- **One abstraction level above eris**: message components and interactions are easier.

When discord.js does not fit: extreme memory pressure (shared hosting), or you want to be closer to the raw gateway — then you look at eris.

4. Discord.py resurrected (April 2024, Rapptz) — back from deprecation

Discord.py was the gold standard for Python Discord bots. Then in **August 2021** the maintainer Rapptz (Danny Garcia) announced he would stop maintaining the library and archived the GitHub repository. The reason: Discord had moved message content into a privileged intent, requiring bots over 100 servers to get explicit Discord approval. Rapptz publicly disagreed — he felt the change killed entire bot categories like music bots — and stepped away, citing the moral burden of maintaining a library whose ecosystem was being squeezed.

The Python Discord ecosystem panicked. Tens of thousands of bots depended on discord.py, and new Discord features — slash commands, interactions, threads — could not be used without library updates.

Two and a half years of silence

From August 2021 through April 2024, discord.py was effectively frozen. During that window the community produced **forks** (next section). Some thrived, some faded.

April 2024 — the return

In **April 2024** Rapptz announced he was reviving discord.py. Discord had softened parts of the music-bot policy, and he had had time to process the burnout. The day he made the announcement, Twitter, Reddit, and the Discord developer servers lit up.

After the return, discord.py caught up fast.

- Slash commands (`app_commands`)

- Modals and select menus

- Threads and forum channels

- Voice v3

- Voice receive (built into the library)

In 2026, **discord.py 2.x** is once again the de facto standard for Python Discord bots.

Minimal skeleton

from discord import app_commands

from discord.ext import commands

intents = discord.Intents.default()

intents.message_content = True

bot = commands.Bot(command_prefix='!', intents=intents)

@bot.event

async def on_ready():

print(f'Logged in as {bot.user}')

await bot.tree.sync()

@bot.tree.command(name='ping', description='Measure latency')

async def ping(interaction: discord.Interaction):

latency = round(bot.latency * 1000)

await interaction.response.send_message(f'Pong ({latency}ms)')

bot.run('YOUR_TOKEN')

Cogs — the module system

`commands.Cog` packages commands, events, and listeners into classes — essentially mandatory for any serious bot.

from discord.ext import commands

from discord import app_commands

class Moderation(commands.Cog):

def __init__(self, bot):

self.bot = bot

@app_commands.command(name='kick', description='Kick a user')

async def kick(self, interaction: discord.Interaction, member: discord.Member):

await member.kick()

await interaction.response.send_message(f'Kicked {member}')

async def setup(bot):

await bot.add_cog(Moderation(bot))

Who picks discord.py

- Teams with significant existing Python assets

- Bots that share a codebase with LLM / data pipelines

- Anyone who likes Rapptz's design philosophy: explicit, type-safe, "low magic"

5. py-cord / nextcord — the forks born during the absence

During the 2.5-year silence, multiple forks emerged. Two survived prominently.

py-cord — the largest fork

**py-cord** gathered the biggest community of the forks. It started in late 2021 and pushed slash commands / interactions aggressively. Its API is very close to discord.py, but it diverged on some decisions (voice handling, name collision resolution).

from discord.ext import commands

bot = commands.Bot()

@bot.slash_command(name='ping', description='Latency')

async def ping(ctx: discord.ApplicationContext):

await ctx.respond(f'Pong ({round(bot.latency * 1000)}ms)')

bot.run('TOKEN')

py-cord supported slash commands earlier and more deeply, which is why many bots migrated to it during the absence.

nextcord — the other fork

**nextcord** stayed slightly closer to discord.py-style ergonomics. It preferred conservative, incremental changes.

from nextcord.ext import commands

bot = commands.Bot(command_prefix='!')

@bot.slash_command(description='Latency')

async def ping(interaction: nextcord.Interaction):

await interaction.send(f'Pong')

bot.run('TOKEN')

After the resurrection — what happens to the forks

Once the upstream returned in April 2024, the forks' value proposition weakened. py-cord is still active, but **new projects largely default back to discord.py**. nextcord has slowed.

Existing py-cord / nextcord bots tend to stay put because migration is expensive. The 2026 decision matrix:

| Situation | Recommendation |

| --- | --- |

| New Python Discord bot | discord.py |

| Existing py-cord bot | Keep (still actively maintained) |

| Existing nextcord bot | Consider migration (development slowing) |

6. JDA / Discord4J — the Java camp

Java Discord bots split between two libraries.

JDA — imperative standard

**JDA** (Java Discord API) is the de facto Java standard. Imperative API, strong types, rich docs.

public class Bot extends ListenerAdapter {

public static void main(String[] args) throws Exception {

JDABuilder.createDefault(System.getenv("DISCORD_TOKEN"))

.enableIntents(GatewayIntent.MESSAGE_CONTENT)

.addEventListeners(new Bot())

.build();

}

@Override

public void onReady(ReadyEvent event) {

System.out.println("Login: " + event.getJDA().getSelfUser().getAsTag());

}

JDA has separate Spring and Quarkus integration libraries, so enterprise teams can use familiar patterns.

Discord4J — reactive

**Discord4J** is built on Project Reactor, expressing everything as reactive streams. Very natural if your team already uses Reactor / WebFlux.

public class Bot {

public static void main(String[] args) {

var client = DiscordClient.create(System.getenv("DISCORD_TOKEN"))

.login()

.block();

client.on(MessageCreateEvent.class, event -> {

var message = event.getMessage();

if (message.getContent().equals("!ping")) {

return message.getChannel()

.flatMap(channel -> channel.createMessage("Pong"));

}

return reactor.core.publisher.Mono.empty();

}).blockLast();

}

Who picks which

| Team flavor | Recommendation |

| --- | --- |

| Imperative Spring Boot | JDA |

| Reactor / WebFlux | Discord4J |

| Just want Java fast | JDA (lower learning curve) |

| High-concurrency event processing | Discord4J (backpressure) |

7. serenity (Rust) / DSharpPlus + discord.net (.NET) / eris

serenity — Rust Discord standard

**serenity** is the standard for Rust Discord bots. async/await, strong types, memory safe. Popular for large bots and resource-constrained deployments.

use serenity::async_trait;

use serenity::model::channel::Message;

use serenity::prelude::*;

struct Handler;

#[async_trait]

impl EventHandler for Handler {

async fn message(&self, ctx: Context, msg: Message) {

if msg.content == "!ping" {

if let Err(why) = msg.channel_id.say(&ctx.http, "Pong").await {

println!("Send failed: {:?}", why);

}

#[tokio::main]

async fn main() {

let token = std::env::var("DISCORD_TOKEN").expect("no token");

let intents = GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;

let mut client = Client::builder(&token, intents)

.event_handler(Handler)

.await

.expect("client build failed");

if let Err(why) = client.start().await {

println!("Runtime error: {:?}", why);

}

DSharpPlus / Discord.Net — the .NET duo

The .NET camp has two coexisting libraries.

- **DSharpPlus**: more actively chasing new features.

- **Discord.Net**: older, used by many large bots. Solid slash command support.

using Discord;

using Discord.WebSocket;

var client = new DiscordSocketClient(new DiscordSocketConfig {

GatewayIntents = GatewayIntents.AllUnprivileged | GatewayIntents.MessageContent

});

client.Log += msg => { Console.WriteLine(msg.ToString()); return Task.CompletedTask; };

client.MessageReceived += async msg => {

if (msg.Content == "!ping") await msg.Channel.SendMessageAsync("Pong");

};

await client.LoginAsync(TokenType.Bot, Environment.GetEnvironmentVariable("DISCORD_TOKEN"));

await client.StartAsync();

await Task.Delay(-1);

eris — older Node, still hanging on

**eris** is the previous-generation Node Discord library. Closer to the raw gateway, more memory-efficient, still used by some large bots. For a new project, prefer discord.js.

const Eris = require('eris');

const bot = new Eris(process.env.DISCORD_TOKEN, {

intents: ['guilds', 'guildMessages', 'messageContent'],

});

bot.on('ready', () => console.log('Ready'));

bot.on('messageCreate', (msg) => {

if (msg.content === '!ping') bot.createMessage(msg.channel.id, 'Pong');

});

bot.connect();

8. Matrix bots — matrix-nio (Python) / matrix-bot-sdk (Node)

Matrix is an open protocol, so SDKs are scattered across languages. The two most common for bots:

matrix-nio — async Python

from nio import AsyncClient, MatrixRoom, RoomMessageText

async def message_callback(room: MatrixRoom, event: RoomMessageText):

if event.body == "!ping":

await client.room_send(

room_id=room.room_id,

message_type="m.room.message",

content={"msgtype": "m.text", "body": "Pong"},

)

client = AsyncClient("https://matrix.example.org", "@bot:example.org")

client.add_event_callback(message_callback, RoomMessageText)

matrix-bot-sdk — Node

const client = new MatrixClient(

'https://matrix.example.org',

process.env.MATRIX_TOKEN!,

new SimpleFsStorageProvider('bot.json'),

);

client.on('room.message', async (roomId, event) => {

if (!event.content || event.sender === (await client.getUserId())) return;

if (event.content.body === '!ping') {

await client.sendMessage(roomId, { msgtype: 'm.text', body: 'Pong' });

}

});

client.start();

Who uses Matrix

- Open-source communities (Mozilla, KDE, GNOME)

- Governments and public sector (France Tchap, Germany BWMessenger)

- Organizations that need federation

Several enterprises picked Matrix plus Element as a Slack alternative. Bot development is slightly harder than Slack or Discord, but self-hosting, federation, and E2EE are big wins.

9. Mattermost / Rocket.Chat — enterprise chat

Mattermost — the Slack replacement of choice

**Mattermost** is the most common self-hosted Slack replacement. Its bot API closely mirrors Slack's.

from mattermostdriver import Driver

driver = Driver({

'url': 'mattermost.example.com',

'token': 'BOT_TOKEN',

'scheme': 'https',

'port': 443,

})

driver.login()

Send a message

driver.posts.create_post({

'channel_id': 'CHANNEL_ID',

'message': 'Hello',

})

Mattermost supports slash commands, interactive messages, and webhooks. Porting Slack bot code is relatively cheap.

Rocket.Chat — the other side

**Rocket.Chat** is another open-source, self-hosted messenger. You build bots either with the Rocket.Chat Apps Engine or via REST API + webhooks.

const { RocketChatApp } = require('@rocket.chat/apps-engine/definition/RocketChatApp');

class HelloApp extends RocketChatApp {

async executeSlashCommand(context, read, modify) {

const sender = context.getSender();

const room = context.getRoom();

const builder = modify.getCreator().startMessage()

.setSender(sender)

.setRoom(room)

.setText('Hello!');

await modify.getCreator().finish(builder);

}

Who uses Mattermost / Rocket.Chat

- Governments and the public sector needing data sovereignty

- Large organizations wanting to avoid Slack licensing costs

- Regulated environments (military, finance)

10. Telegram — python-telegram-bot / Telegraf (Node) / aiogram

The Telegram Bot API is HTTP-based and can be used from any language, but each language has its standard.

python-telegram-bot — Python sync and async

The oldest, largest Python Telegram library. Fully async from v20 (2022).

from telegram import Update

from telegram.ext import Application, CommandHandler, ContextTypes

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):

await update.message.reply_text('Hello!')

app = Application.builder().token('YOUR_TOKEN').build()

app.add_handler(CommandHandler('start', start))

app.run_polling()

Telegraf — Node standard

const bot = new Telegraf(process.env.TELEGRAM_TOKEN!);

bot.start((ctx) => ctx.reply('Hello!'));

bot.command('ping', (ctx) => ctx.reply('Pong'));

bot.launch();

aiogram — asyncio-native Python

asyncio-first. Better suited to large, highly concurrent bots.

from aiogram import Bot, Dispatcher, types

from aiogram.filters import Command

bot = Bot(token='YOUR_TOKEN')

dp = Dispatcher()

@dp.message(Command('start'))

async def handle_start(message: types.Message):

await message.answer('Hello!')

async def main():

await dp.start_polling(bot)

asyncio.run(main())

Who picks which

| Situation | Recommendation |

| --- | --- |

| New Python Telegram bot | python-telegram-bot (largest community) |

| High concurrency, async-first | aiogram |

| Node environment | Telegraf |

| Heavy TypeScript types | Telegraf (great typings) |

11. WhatsApp Cloud API (Meta)

Since 2022, WhatsApp business messaging standardized on **Meta's Cloud API**. Previously you went through a BSP (Business Solution Provider); now you integrate directly with the Meta Cloud API.

Basic flow

1. Create an app in Meta for Developers

2. Connect a WhatsApp Business Account (WABA)

3. Register and verify a phone number

4. Register your webhook URL (for incoming messages)

5. Send messages via the Graph API

Sending a message (HTTP)

curl -X POST "https://graph.facebook.com/v18.0/PHONE_NUMBER_ID/messages" \

-H "Authorization: Bearer ACCESS_TOKEN" \

-H "Content-Type: application/json" \

-d '{

"messaging_product": "whatsapp",

"to": "12025550123",

"type": "text",

"text": {"body": "Hello"}

Template messages — outside the 24-hour window

WhatsApp enforces a **24-hour window** rule. Outside 24 hours since the user's last message, you cannot send free-form messages — only **pre-approved templates**.

curl -X POST "https://graph.facebook.com/v18.0/PHONE_NUMBER_ID/messages" \

-H "Authorization: Bearer ACCESS_TOKEN" \

-H "Content-Type: application/json" \

-d '{

"messaging_product": "whatsapp",

"to": "12025550123",

"type": "template",

"template": {

"name": "order_confirmation",

"language": {"code": "en"}

}

Who uses WhatsApp

- Businesses targeting Southeast Asia, India, Latin America, parts of Europe

- Global SaaS using WhatsApp as a notification channel

- In Korea it is marginal — KakaoTalk dominates

12. LINE Messaging API

**LINE** dominates messaging in Japan, Taiwan, and Thailand. Business bots and official accounts run on the LINE Messaging API.

Basic flow

1. Create a Provider and channel in LINE Developers

2. Enable the Messaging API channel

3. Issue a Channel Access Token

4. Register a webhook URL

5. Send messages via SDK or raw HTTP

Node SDK example

const config = {

channelAccessToken: process.env.LINE_ACCESS_TOKEN!,

channelSecret: process.env.LINE_CHANNEL_SECRET!,

};

const client = new Client(config);

const app = express();

app.post('/webhook', middleware(config), async (req, res) => {

const events = req.body.events;

for (const event of events) {

if (event.type === 'message' && event.message.type === 'text') {

await client.replyMessage(event.replyToken, {

type: 'text',

text: `Echo: ${event.message.text}`,

});

}

res.sendStatus(200);

});

app.listen(3000);

Python SDK example

from linebot import LineBotApi, WebhookHandler

from linebot.models import MessageEvent, TextMessage, TextSendMessage

from flask import Flask, request

app = Flask(__name__)

line_bot_api = LineBotApi('YOUR_ACCESS_TOKEN')

handler = WebhookHandler('YOUR_CHANNEL_SECRET')

@app.route('/webhook', methods=['POST'])

def webhook():

signature = request.headers['X-Line-Signature']

body = request.get_data(as_text=True)

handler.handle(body, signature)

return 'OK'

@handler.add(MessageEvent, message=TextMessage)

def handle_message(event):

line_bot_api.reply_message(

event.reply_token,

TextSendMessage(text=f'Echo: {event.message.text}')

)

LINE Rich Menu and Flex Message

LINE's characteristic features are the **Rich Menu** (a docked menu at the bottom of the chat) and **Flex Message** (custom UI defined in a JSON DSL). Standard fare in commerce, booking, and customer support bots.

LINE Bot Designer (Japan)

In Japan, **LINE Bot Designer** is a GUI tool that lets non-developers build Flex Messages and scenarios. Marketing teams use it to run bot content without writing code.

13. KakaoTalk Channel API

**KakaoTalk Channel** is the dominant business messaging channel in Korea. The API model is noticeably different from Slack, Discord, or LINE.

Two message categories

1. **KakaoTalk Channel messages** — marketing or update messages to users who have added the channel. Subject to policy review.

2. **Notification Talk / Friend Talk** — informational notifications (payments, bookings, deliveries). Templates must be pre-registered. Frequently sent through a BSP (an official business message agency).

Kakao i Open Builder — the chat bot builder

**Kakao i Open Builder** is the official tool for building KakaoTalk Channel chat bots. You design scenarios, utterances, and blocks in a GUI, then connect to an external server via webhook.

Flow:

1. User sends a message to the channel

2. Kakao i Open Builder matches the utterance to a block

3. The block sends a webhook to your skill server

4. Your skill server returns a JSON response

5. Kakao delivers the message to KakaoTalk

Skill server example (Python Flask)

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/skill/order-status', methods=['POST'])

def order_status():

data = request.json

user_id = data['userRequest']['user']['id']

utterance = data['userRequest']['utterance']

Real lookup would hit a DB

status = 'In transit'

response = {

'version': '2.0',

'template': {

'outputs': [{

'simpleText': {

'text': f'Order status: {status}'

}

}]

}

return jsonify(response)

if __name__ == '__main__':

app.run(port=5000)

Notification Talk flow

Korean law (the Information and Communications Network Act) draws a strict line between informational and advertising messages. The flow:

1. Register a sender profile (requires a business registration)

2. Submit a template for review (Kakao review, typically days)

3. Send only approved templates

4. Substitute variables into the approved body

Why Korean businesses cannot avoid KakaoTalk

- Overwhelming share of the Korean messenger market

- Used by virtually all consumers daily

- The Kakao ecosystem covers payments, authentication, and customer service

The trade-off is heavier operational overhead than Slack or Discord — policy reviews, template approvals, BSP contracts.

14. Korea / Japan — KakaoTalk Channel, LINE bots, KARTE Talk Bot

Korea — KakaoTalk + Notification Talk + chat bot builder

A typical Korean business bot stack:

- Marketing and updates: KakaoTalk Channel messages

- Informational alerts (payments, deliveries, bookings): Notification Talk via a BSP

- Chat bots (support, FAQ): Kakao i Open Builder plus a skill server

- Internal collaboration: Slack or JANDI

Japan — LINE dominant

Typical Japanese business bot stack:

- Marketing and customer interaction: LINE Official Account

- Chat bots: LINE Messaging API plus a self-hosted server, or LINE Bot Designer

- Marketing automation: KARTE Talk Bot (the chat bot feature of KARTE)

- Internal collaboration: Slack, Microsoft Teams, Chatwork

KARTE Talk Bot — the Japanese SaaS case

KARTE is a major Japanese CX (customer experience) platform, with a chat bot component called Talk Bot. You pick it when you want marketing automation, segmentation, and chat bot delivery in one place. Common on Japanese e-commerce and media sites.

The reality of multi-platform bots

If you go global, one bot ends up speaking Slack, Discord, LINE, KakaoTalk, and Telegram. The typical pattern:

1. **Common bot core**: business logic, state, LLM calls — your own service.

2. **Platform adapters**: a thin layer per platform handling webhooks and message transformation.

3. **Normalized message model**: text, image, button, card mapped to a common representation.

Some teams build all of this in-house; others adopt multi-channel SaaS like Sendbird, Customer.io, or Twilio Conversations.

15. Who picks what — company Slack / community Discord / KakaoTalk business

Finally, scenario-by-scenario recommendations.

Company Slack bot (internal tooling)

- **Node standard**: Bolt Node + Socket Mode

- **Python standard**: Bolt Python + Socket Mode

- **Java / Kotlin standard**: Bolt Java

- **Minimize startup cost**: Socket Mode, single workspace token

Self-hosted internal collaboration

- **Slack replacement, self-hosted**: Mattermost + Python or Node bots

- **Open-source federation**: Matrix + matrix-nio

- **Lightweight free option**: Rocket.Chat + Apps Engine

Community Discord bot

- **Node team**: discord.js

- **Python team**: discord.py (recommended for new bots after the revival); keep existing py-cord bots

- **Java team**: JDA for imperative, Discord4J if reactive

- **Rust team**: serenity

- **.NET team**: DSharpPlus (more active) or Discord.Net (more stable)

Global message notifications

- **North America, Europe, consumer**: WhatsApp Cloud API (dominant in Brazil, India)

- **Japan, Taiwan, Thailand**: LINE Messaging API

- **Korea**: KakaoTalk Channel + Notification Talk via BSP

- **Global IT and developers**: Telegram (python-telegram-bot / aiogram / Telegraf)

Integrated Korea / Japan business

- **Korea B2C**: Kakao i Open Builder + Notification Talk (BSP) + internal Slack

- **Japan B2C**: LINE Messaging API + KARTE Talk Bot + internal Slack or Teams

- **Both markets**: common bot core + platform adapters (in-house or SaaS)

Migration guide

| Currently | Recommended path |

| --- | --- |

| Discord.py from before 2021 | Upgrade to 2.x (revived) |

| Discord.py fork (py-cord) | Keep, but use discord.py for new bots |

| Discord.py fork (nextcord) | Consider migrating to discord.py |

| eris (Node) | discord.js (performance gap has narrowed) |

| node-telegram-bot-api | Telegraf (better typings, ecosystem) |

| python-telegram-bot v13 | v20+ (now async) |

16. Closing — picking a chat bot framework is an interface decision

Picking a chat bot framework is not just a technical decision; it is an **interface decision**. Which messenger users meet you in, which language your team can sustain operations in, whether you can live with the platform's policy environment.

The 2026 summary:

- **Slack**: unified on Bolt. The absolute incumbent for internal tooling.

- **Discord**: the absolute incumbent for community. Every language camp has a solid library. Python is stable again after the discord.py revival.

- **Matrix / Mattermost / Rocket.Chat**: when you need self-hosting or federation.

- **Telegram**: developer communities and international users.

- **WhatsApp / LINE / KakaoTalk**: B2C, regional. Accept the policy overhead.

One last question when deciding to build a bot: **who maintains this bot a year from now?** Bots are easy to build but stubborn to operate. Once users depend on them, turning them off is hard. So you weigh framework survival, your team's capacity, and the platform's policy stability — all three — before committing.

The best bots are the ones users do not even realize are bots. That is what a well-designed interface looks like.

References

Slack

- Slack Bolt for JavaScript: https://slack.dev/bolt-js/

- Slack Bolt for Python: https://slack.dev/bolt-python/

- Slack Bolt for Java: https://slack.dev/java-slack-sdk/guides/bolt

- Slack API: https://api.slack.com/

Discord — Node

- discord.js: https://discord.js.org/

- discord.js Guide: https://discordjs.guide/

- eris: https://github.com/abalabahaha/eris

Discord — Python

- discord.py: https://github.com/Rapptz/discord.py

- discord.py revival announcement (2024): https://gist.github.com/Rapptz/4a2f62751b9600a31a0d3c78100287f1

- py-cord: https://github.com/Pycord-Development/pycord

- nextcord: https://github.com/nextcord/nextcord

Discord — Java / Rust / .NET

- JDA: https://github.com/discord-jda/JDA

- Discord4J: https://github.com/Discord4J/Discord4J

- serenity (Rust): https://github.com/serenity-rs/serenity

- DSharpPlus: https://github.com/DSharpPlus/DSharpPlus

- Discord.Net: https://github.com/discord-net/Discord.Net

Matrix / Mattermost / Rocket.Chat

- matrix-nio (Python): https://github.com/matrix-nio/matrix-nio

- matrix-bot-sdk (Node): https://github.com/turt2live/matrix-bot-sdk

- Mattermost API: https://api.mattermost.com/

- mattermostdriver (Python): https://vaelor.github.io/python-mattermost-driver/

- Rocket.Chat Apps Engine: https://developer.rocket.chat/

- Telegram Bot API: https://core.telegram.org/bots/api

- python-telegram-bot: https://github.com/python-telegram-bot/python-telegram-bot

- aiogram: https://github.com/aiogram/aiogram

- Telegraf: https://github.com/telegraf/telegraf

WhatsApp / LINE / KakaoTalk

- WhatsApp Cloud API: https://developers.facebook.com/docs/whatsapp/cloud-api/

- LINE Messaging API: https://developers.line.biz/en/services/messaging-api/

- LINE Bot SDK Node: https://github.com/line/line-bot-sdk-nodejs

- LINE Bot SDK Python: https://github.com/line/line-bot-sdk-python

- Kakao i Open Builder: https://i.kakao.com/openbuilder

- KakaoTalk Channel Message API: https://developers.kakao.com/docs/latest/ko/message/rest-api

- KARTE Talk: https://karte.io/product/talk/