Connect Claude to Telegram Business — supervised AI replies

1. Create a bot via @BotFather (/newbot).
2. In Telegram, Settings → Telegram Business → Chatbots. Paste your bot’s @username. Grant Read incoming messages + Reply on your behalf.
3. In your bot code, listen for business_connection updates to know when you’ve been connected, and store the resulting business_connection_id — you’ll need it on every outgoing reply.

// pseudo-code; pick your favorite framework
bot.on("business_connection", async (update) => {
  await db.businessConnection.upsert({
    where: { userId: update.user.id },
    update: { id: update.id, can_reply: update.can_reply },
    create: { id: update.id, userId: update.user.id, can_reply: update.can_reply },
  });
});

Telegram sends a business_message update when someone DMs your account. The shape is identical to a regular message, with an extra business_connection_id.

bot.on("business_message", async (update) => {
  const msg = update.business_message;
  await db.message.create({
    data: {
      direction: "in",
      chatId: msg.chat.id,
      fromUserId: msg.from.id,
      text: msg.text,
      receivedAt: new Date(msg.date * 1000),
      businessConnectionId: update.business_connection_id,
    },
  });
  await draftReply(msg);
});

The chat.id is the customer’s user id. Storing the conversation thread keyed on it is the simplest model.

Claude needs three things to draft well: who you are, what you’ve already said, and what just came in.

async function draftReply(incomingMsg) {
  const history = await db.message.findMany({
    where: { chatId: incomingMsg.chat.id },
    orderBy: { receivedAt: "desc" },
    take: 20,
  });

  const conversation = history.reverse().map((m) => ({
    role: m.direction === "in" ? "user" : "assistant",
    content: m.text,
  }));

  const draft = await anthropic.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 600,
    system: SYSTEM_PROMPT,
    messages: [
      ...conversation,
      { role: "user", content: incomingMsg.text },
    ],
  });

  return draft.content[0].text;
}

The system prompt is where most of the work happens. Keep it short, specific, and firmly in your voice:

You draft Telegram DM replies on behalf of {your_name}, a {your_role}.
Voice: warm, concise, never gushing. Lowercase i for "I" only when the
human you're replying to does first.

Rules:
- Reply in the same language as the incoming message.
- If the message asks for a price, link them to /pricing rather than
  quoting (the human will adjust).
- Never promise calendar times. Suggest "later this week" and let
  the human commit.
- If the message is unclear, ask one clarifying question.
- If the message is hostile or spammy, draft a polite one-liner
  closing the thread.
- Maximum 4 sentences unless the user asks for detail.

Iterate on this prompt for two weeks. It’s the difference between drafts you ship 90% of the time vs 30%.

Create a private channel in your account (“Drafts”). Add your bot as admin. Every draft posts there as a message with two inline buttons: Send and Edit.

async function postDraftForApproval(incomingMsg, draftText) {
  await bot.api.sendMessage(DRAFTS_CHANNEL_ID, formatPreview(incomingMsg, draftText), {
    reply_markup: {
      inline_keyboard: [[
        { text: "✓ Send", callback_data: `send:${incomingMsg.chat.id}:${draftId}` },
        { text: "✎ Edit", callback_data: `edit:${incomingMsg.chat.id}:${draftId}` },
      ]],
    },
  });
}

function formatPreview(incomingMsg, draftText) {
  return `*From* ${incomingMsg.from.first_name} (@${incomingMsg.from.username || "—"})

> ${incomingMsg.text}

---
*Draft:*

${draftText}`;
}

The Drafts channel becomes your morning queue. Skim, tap Send on what’s right, Edit on what’s not.

On callback, your bot uses the stored business_connection_id to send the reply on your behalf:

bot.on("callback_query", async (cq) => {
  const [action, chatId, draftId] = cq.data.split(":");
  const draft = await db.draft.findUnique({ where: { id: draftId } });
  const conn = await db.businessConnection.findFirst();

  if (action === "send") {
    await bot.api.sendMessage(Number(chatId), draft.text, {
      business_connection_id: conn.id,
    });
    await db.message.create({
      data: { direction: "out", chatId: Number(chatId), text: draft.text, sentAt: new Date() },
    });
    await bot.api.editMessageText(DRAFTS_CHANNEL_ID, cq.message.message_id, "✓ Sent: " + draft.text);
  }

  await bot.api.answerCallbackQuery(cq.id);
});

business_connection_id is what tells Telegram “this message comes from the user’s account, not the bot’s.” Without it, the customer sees the reply from your bot, not from you — different relationship entirely.

Tap Edit → bot sends the draft text back to the Drafts channel as a regular message with a force_reply so you can edit and reply. Your reply becomes the new draft. Tap Send on the edited version.

A two-tap flow for the common case (it’s good), three taps for the edit case (it’s not perfect, fix it).