How to Build a Telegram AI Customer Support Bot with n8n

Running customer support around the clock without burning out your team is one of the hardest operational problems a growing business faces. Customers expect instant replies, but hiring an agent for every timezone is expensive and unsustainable. This n8n workflow connects a Telegram bot, Google Gemini, and Supabase to build a support bot that reads conversation history, generates intelligent replies, and responds in under 3 seconds, around the clock, automatically. Telegram is free with no per-message fee, and Gemini’s free tier means the AI costs nothing to run at typical volume.

Want a ready-made agent instead? The Shopify AI Customer Support Agent is a tested, import-ready template built on the same idea.

What You’ll Build

1. A customer sends a message to your Telegram bot at any hour.
2. n8n receives the message through the Telegram Trigger node.
3. The workflow fetches the customer’s last 10 messages from Supabase so the AI has full context.
4. Google Gemini reads the conversation history and generates a helpful, on-brand reply.
5. The exchange is saved to Supabase and the reply is sent back to the customer, typically within 2 to 3 seconds.

How It Works: The Big Picture

The workflow is a single pipeline triggered by the Telegram Trigger node. Every incoming message flows through a filter, a context-retrieval step, an AI generation step, and two write operations, one to store the conversation and one to deliver the reply.

┌──────────────────────────────────────────────────────────┐
│  TELEGRAM AI CUSTOMER SUPPORT BOT                        │
│                                                          │
│  [Telegram Trigger]                                      │
│         |                                                │
│         v                                                │
│  [Is Text Message?] --(No)--> [Stop]                     │
│         | (Yes)                                          │
│         v                                                │
│  [Extract Message Data]                                  │
│         |                                                │
│         v                                                │
│  [Get History · Supabase]                                │
│         |                                                │
│         v                                                │
│  [Build Gemini Request]                                  │
│         |                                                │
│         v                                                │
│  [Google Gemini · generateContent]                       │
│         |                                                │
│         v                                                │
│  [Store Conversation · Supabase]                         │
│         |                                                │
│         v                                                │
│  [Send Telegram Reply]                                   │
└──────────────────────────────────────────────────────────┘
  

What You’ll Need

• n8n instance: Cloud or self-hosted (v1.0 or higher)
• Telegram bot token: created in two minutes with @BotFather, completely free, no approval or phone number setup
• Google Gemini API key: from Google AI Studio, free tier, no credit card, no OpenAI subscription needed
• Supabase account: the free tier handles thousands of daily conversations
• One conversations table in Supabase (SQL provided below)

Estimated build time: 40 to 50 minutes from scratch.

Part 1: Building the Workflow Step by Step

1 Create your Telegram bot (2 minutes)

Open Telegram and message @BotFather. Send /newbot, give it a name and a username, and BotFather replies with a bot token that looks like 7123456789:AAH.... Copy it. That single token is all the authentication your bot needs, there is no business verification, phone number, or app review to wait on.

2 Telegram Trigger (Telegram Trigger node)

Add the Telegram Trigger node. Create a Telegram credential and paste your bot token, then set Updates to message. n8n registers the webhook with Telegram for you, so there is no URL to copy or verify by hand.

Here is what a typical incoming update looks like:

{
  "message": {
    "message_id": 4021,
    "from": { "id": 15551234567, "first_name": "James" },
    "chat": { "id": 15551234567, "type": "private" },
    "date": 1775745137,
    "text": "Hi, where is my order #1042?"
  }
}

3 Is Text Message? (IF node)

Not every update is a customer message. Edits, stickers, and service events arrive through the same trigger without a plain message.text. This IF node gates those out to avoid errors downstream.

Configure the condition:

1. Left Value: {{ $json.message.text }}
2. Operation: exists (is not empty)

The True branch continues to message processing. The False branch simply ends, Telegram does not need any acknowledgment from your workflow.

4 Extract Message Data (Set node)

This Set node flattens the fields we need into a clean object so every downstream node can reference data without long expression chains. The chat ID is the key that identifies each customer’s conversation.

After this node, the data looks like:

{
  "chatId": 15551234567,
  "message": "Hi, where is my order #1042?",
  "messageId": 4021,
  "firstName": "James",
  "timestamp": "2026-04-05T14:32:17.000Z"
}

5 Get Conversation History (HTTP Request to Supabase)

Before calling Gemini, we fetch the customer’s history so the AI understands context: was this their first message? Did they already explain the issue? This node queries Supabase’s REST API for the last 10 messages from this chat.

1. Method: GET
2. URL: https://YOUR_SUPABASE_PROJECT_REF.supabase.co/rest/v1/conversations
3. Header apikey: your Supabase anon/public key
4. Header Authorization: Bearer YOUR_SUPABASE_ANON_KEY
5. Query param chat_id: eq.{{ $('Extract Message Data').item.json.chatId }}
6. Query param order: created_at.desc
7. Query param limit: 10

Returns up to 10 rows, or an empty array for a brand-new customer, which is handled gracefully in the next step.

6 Build Gemini Request (Code node)

This is the brain of the operation. The Code node takes the Supabase history, reverses it to chronological order, and builds the exact request body Google Gemini’s generateContent API expects: a system_instruction that sets the bot’s personality, and a contents array of the conversation so far.

const history = $input.all();
const current = $('Extract Message Data').item.json.message;
const chatId  = $('Extract Message Data').item.json.chatId;

// System instruction defines the bot's personality and knowledge
const systemText = `You are a friendly and professional customer support assistant
for our online store. Be concise, empathetic, and helpful.
Answer questions about orders, shipping, returns, and products.
If you cannot resolve an issue, ask the customer to email
support@yourstore.com with their order number.
Keep replies under 150 words.`;

// Gemini uses role "user" and "model"; map stored "assistant" to "model"
const contents = history.map(i => i.json)
  .filter(m => m.role && m.content)
  .reverse()
  .map(m => ({
    role: m.role === 'assistant' ? 'model' : 'user',
    parts: [{ text: m.content }]
  }));

// Add the current incoming message
contents.push({ role: 'user', parts: [{ text: current }] });

return [{ json: {
  chatId,
  currentMessage: current,
  body: {
    system_instruction: { parts: [{ text: systemText }] },
    contents
  }
} }];

7 Google Gemini (HTTP Request to generateContent)

Sends the full conversation to Gemini and receives a natural, contextual reply. Using an HTTP Request node gives you full control over the request format, and Gemini’s free tier keeps this step free at typical support volume.

1. Method: POST
2. URL: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent
3. Header x-goog-api-key: YOUR_GEMINI_API_KEY
4. Header Content-Type: application/json
5. Body (JSON expression): ={{ $json.body }}

The response object looks like this:

{
  "candidates": [{
    "content": {
      "role": "model",
      "parts": [{ "text": "Hi! I'd be happy to look into order #1042 for you. Could you confirm the email on the order so I can pull it up?" }]
    },
    "finishReason": "STOP"
  }]
}

Access the reply downstream with $json.candidates[0].content.parts[0].text.

8 Store Conversation (HTTP Request to Supabase)

Saves both the customer’s message and the AI’s reply to Supabase in a single bulk insert. This is what gives the bot memory: every message is persisted for future context retrieval.

1. Method: POST
2. URL: https://YOUR_SUPABASE_PROJECT_REF.supabase.co/rest/v1/conversations
3. Headers: same apikey and Authorization as Step 5, plus Content-Type: application/json and Prefer: return=minimal
4. Body: a JSON array with two objects, the user message and the assistant reply

=[
  {
    "chat_id": "={{ $('Build Gemini Request').item.json.chatId }}",
    "role": "user",
    "content": "={{ $('Build Gemini Request').item.json.currentMessage }}"
  },
  {
    "chat_id": "={{ $('Build Gemini Request').item.json.chatId }}",
    "role": "assistant",
    "content": "={{ $json.candidates[0].content.parts[0].text }}"
  }
]

9 Send Telegram Reply (Telegram node)

Delivers the AI-generated response back to the customer. Add the Telegram node (not the trigger), reuse your bot credential, and configure:

1. Resource: Message, Operation: Send Message
2. Chat ID: ={{ $('Extract Message Data').item.json.chatId }}
3. Text: ={{ $('Google Gemini').item.json.candidates[0].content.parts[0].text }}

That is the whole delivery step. No phone number formatting, no Graph API version, no message templates to get approved.

The Data Structure

The entire conversation memory lives in a single Supabase table. Create it by running this SQL in the Supabase dashboard under SQL Editor:

CREATE TABLE conversations (
  id          bigint primary key generated always as identity,
  chat_id     text        not null,
  role        text        not null check (role in ('user', 'assistant')),
  content     text        not null,
  created_at  timestamptz not null default now()
);

CREATE INDEX idx_conversations_chat_id    ON conversations(chat_id);
CREATE INDEX idx_conversations_created_at ON conversations(created_at);

Testing Your Workflow

1. Open Telegram, find your bot by its username, and send it a message like “Hi, where is my order #1042?”
2. Open n8n and watch the Executions panel, a new execution should appear within a second.
3. Verify the IF node routed to the True branch and every node shows a green checkmark.
4. Check your Supabase conversations table, two new rows should appear (role=user and role=assistant).
5. Check Telegram, the AI reply should have arrived.

Frequently Asked Questions

What’s Next?

• Add order lookup: connect your Shopify store so the bot can answer with real-time order status by number.
• Detect frustrated customers: add a sentiment check, and if the AI detects frustration, route to a Slack alert so a human can jump in.
• Go multilingual: Gemini already replies in the customer’s language when you ask it to in the system instruction, no extra step needed.
• Build a weekly digest: use a Schedule trigger to query Supabase for weekly conversation summaries and email them to your team every Monday.

Browse more ready-to-run options in the best n8n AI agent templates for Shopify, or get order and stock alerts on Telegram.