Setup and Configure Telegram Bot - Complete Guide

Learn how to properly setup and configure your Telegram bot for production.

Pre-Configuration Checklist

Before starting, you need:

• Telegram account
• Bot created on BotFather
• API token saved
• Platform chosen (code/no-code)
• Development environment ready
• Hosting selected

Part 1: BotFather Configuration

Initial Setup with BotFather

1. Find BotFather

   • Open Telegram
   • Search @BotFather
   • Click Start

2. Create Your Bot

   • Send /newbot
   • Choose bot name
   • Choose unique username
   • Receive API token

3. Save Token Securely

   • Copy exact token
   • Store in password manager
   • Add to .env file
   • Never commit to git

Configure Bot Settings

Set Description

/setdescription
Select your bot
Enter description (120 chars max)

Example: "I'm a helpful bot that answers all your questions about Telegram bots."

Set Short Description

/setshortdescription
Select your bot
Enter short description (120 chars max)

Set Commands

/setcommands
Select your bot
Enter commands:
/start - Start the bot
/help - Get help
/settings - Configure settings
/about - About this bot

Set Menu Button

/setmenubutton
Select your bot
Choose action (commands/website/etc)
Configure button

Set Profile Picture

/setuserpic
Select your bot
Upload image (512x512px recommended)

Set Privacy Mode

/setprivacy
Select your bot
Enable (bot sees all messages in groups)
Disable (bot sees only commands)

Allow/Disallow Groups

/setjoingroups
Select your bot
Allow/disallow group usage

Default Admin Rights

/setdefaultadminrights
Select your bot
Choose permissions:
- Delete messages
- Ban users
- Pin messages
- Etc.

Part 2: Development Setup

Choose Your Environment

No-Code (Recommended)

• TelegramFlow
• ManyChat
• Chatfuel

Code-Based

• Python + python-telegram-bot
• Node.js + telegraf
• Go + telebot
• PHP + PHP Telegram Bot

For Python Setup

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Mac/Linux
venv\Scripts\activate     # Windows

# Install dependencies
pip install python-telegram-bot
pip install python-dotenv

# Create project structure
mkdir telegram-bot
cd telegram-bot
touch .env main.py

Environment Variables (.env)

BOT_TOKEN=123456789:ABCDEfghIjklMnopQrstUvwxyz
DATABASE_URL=postgresql://user:pass@localhost/bot_db
WEBHOOK_URL=https://yourdomain.com/webhook
DEBUG=False

Part 3: Core Configuration

Webhook vs Polling

Polling (Simpler, slower)

• Bot asks Telegram for updates
• Works anywhere
• Higher latency
• Higher resource usage

Webhook (Better, faster)

• Telegram sends updates to your server
• Real-time updates
• Lower latency
• More efficient

Basic Python Setup

from telegram import Update
from telegram.ext import Application, CommandHandler

async def start(update: Update, context):
    await update.message.reply_text("Welcome!")

def main():
    app = Application.builder().token("YOUR_TOKEN").build()
    
    app.add_handler(CommandHandler("start", start))
    
    app.run_polling()  # Polling

if __name__ == '__main__':
    main()

Webhook Setup

from telegram import Update
from telegram.ext import Application

async def start(update: Update, context):
    await update.message.reply_text("Welcome!")

async def main():
    app = Application.builder().token("YOUR_TOKEN").build()
    app.add_handler(CommandHandler("start", start))
    
    async with app:
        await app.bot.set_webhook(
            url="https://yourdomain.com/webhook"
        )
        await app.start()
        await asyncio.Event().wait()

if __name__ == '__main__':
    asyncio.run(main())

Part 4: Database Configuration

Choose Database

• PostgreSQL - Recommended, powerful
• MongoDB - NoSQL, flexible
• MySQL - Traditional, reliable
• SQLite - Local development only
• Firebase - Serverless option

PostgreSQL Connection

import psycopg2
from dotenv import load_dotenv
import os

load_dotenv()

connection = psycopg2.connect(
    host=os.getenv("DB_HOST"),
    database=os.getenv("DB_NAME"),
    user=os.getenv("DB_USER"),
    password=os.getenv("DB_PASSWORD")
)

Create Basic Tables

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    telegram_id BIGINT UNIQUE,
    first_name VARCHAR(100),
    last_name VARCHAR(100),
    created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE messages (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    message TEXT,
    created_at TIMESTAMP DEFAULT NOW()
);

Part 5: Security Configuration

API Token Protection

• Store in environment variables
• Never hardcode
• Use secrets manager
• Rotate periodically
• Monitor usage

Input Validation

def validate_input(user_input: str) -> bool:
    if not user_input or len(user_input) > 1000:
        return False
    if any(forbidden in user_input for forbidden in ['<script>', 'DROP']):
        return False
    return True

Rate Limiting

from telegram.ext import ApplicationBuilder, CallbackContext
import time

user_requests = {}

def rate_limit(func):
    async def wrapper(update: Update, context: CallbackContext):
        user_id = update.effective_user.id
        current_time = time.time()
        
        if user_id in user_requests:
            if current_time - user_requests[user_id] < 1:
                await update.message.reply_text(
                    "Too many requests, please wait."
                )
                return
        
        user_requests[user_id] = current_time
        return await func(update, context)
    
    return wrapper

HTTPS/SSL Configuration

import ssl

# For webhook
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
ssl_context.load_cert_chain('cert.pem', 'key.pem')

Part 6: Error Handling

Global Error Handler

async def error_handler(update: Update, context: CallbackContext):
    error_message = f"Update {update} caused error {context.error}"
    logging.error(error_message)
    
    if update and update.message:
        await update.message.reply_text(
            "Sorry, something went wrong. Please try again."
        )

app.add_error_handler(error_handler)

Try-Catch Pattern

async def send_message(update: Update, context: CallbackContext):
    try:
        # Your code here
        await update.message.reply_text("Hello!")
    except TimedOut:
        await update.message.reply_text("Request timeout, please try again.")
    except BadRequest as e:
        logging.error(f"Bad request: {e}")
    except Exception as e:
        logging.error(f"Unexpected error: {e}")

Part 7: Logging Configuration

Setup Logging

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('bot.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

Log Different Events

logger.info(f"User {user_id} started bot")
logger.warning(f"Rate limit exceeded for {user_id}")
logger.error(f"Failed to process update: {e}")

Part 8: Monitoring Setup

Health Check

async def health_check():
    while True:
        try:
            await bot.get_me()
            logger.info("Bot is healthy")
        except Exception as e:
            logger.error(f"Health check failed: {e}")
        await asyncio.sleep(60)

Performance Monitoring

import time

async def monitor_performance(func):
    async def wrapper(*args, **kwargs):
        start_time = time.time()
        result = await func(*args, **kwargs)
        elapsed = time.time() - start_time
        
        if elapsed > 2:
            logger.warning(
                f"{func.__name__} took {elapsed:.2f}s"
            )
        
        return result
    return wrapper

Part 9: Testing Configuration

Unit Tests

import pytest
from unittest.mock import AsyncMock, MagicMock

@pytest.mark.asyncio
async def test_start_command():
    update = MagicMock()
    context = MagicMock()
    
    await start(update, context)
    
    update.message.reply_text.assert_called()

Integration Tests

async def test_full_flow():
    async with Application.builder().token(TEST_TOKEN).build() as app:
        # Test full bot flow
        pass

Part 10: Deployment Configuration

Environment-Specific Config

import os

ENV = os.getenv("ENVIRONMENT", "development")

CONFIG = {
    "development": {
        "DEBUG": True,
        "DB": "sqlite:///dev.db",
        "LOG_LEVEL": "DEBUG"
    },
    "production": {
        "DEBUG": False,
        "DB": os.getenv("DATABASE_URL"),
        "LOG_LEVEL": "WARNING"
    }
}

current_config = CONFIG[ENV]

Docker Configuration

FROM python:3.11

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

CMD ["python", "main.py"]

docker-compose.yml

version: '3'
services:
  bot:
    build: .
    environment:
      - BOT_TOKEN=${BOT_TOKEN}
      - DATABASE_URL=${DATABASE_URL}
    depends_on:
      - postgres
  
  postgres:
    image: postgres:14
    environment:
      - POSTGRES_PASSWORD=password

Part 11: Post-Configuration

Launch Checklist

• Token secure
• Database connected
• Error handling active
• Logging configured
• Monitoring set up
• Tests passing
• Security reviewed
• Webhooks configured
• Backups enabled
• Documentation complete

Monitor After Launch

• Check logs daily
• Monitor error rates
• Track performance
• Update regularly
• Gather user feedback
• Fix issues quickly

Configuration Summary

Total Setup Time: 2-4 hours Complexity: Medium Maintenance: Weekly checks

Common Issues & Fixes

Issue	Cause	Fix
Bot not responding	Wrong token	Verify token in settings
Slow responses	Inefficient code	Optimize queries
Database errors	Connection issue	Check connection string
Rate limiting	Too many requests	Add delays
Crashes	Unhandled errors	Add error handling

Next Steps

1. Configure BotFather settings
2. Set up development environment
3. Create basic handler
4. Set up database
5. Add error handling
6. Configure logging
7. Deploy to production
8. Monitor and optimize

Resources

• Telegram Bot API Docs
• python-telegram-bot Docs
• TelegramFlow Docs

Ready to Configure Your Bot?

Proper configuration is essential for success. Start with the basics and expand as needed.

Get started with TelegramFlow today - We handle configuration complexity for you!