Как создать бота для генерации лидов в Telegram: полный туториал на Python 2026

Как создать бота для генерации лидов в Telegram: полный туториал на Python 2026

Что вы построите: Полнофункциональную систему генерации лидов в Telegram, которая парсит комментарии из целевых групп, классифицирует лиды с помощью ИИ, отправляет персонализированные автоответы и отслеживает всё в дашборде. Стоимость: $0-50/мес.

Содержание

1. Что вы построите
2. Обзор архитектуры
3. Требования
4. Настройка проекта
5. Шаг 1: Сессии аккаунтов Telegram
6. Шаг 2: Поиск и вступление в группы
7. Шаг 3: Парсинг комментариев через Telethon
8. Шаг 4: ИИ-классификация лидов
9. Шаг 5: Бот автоответов
10. Шаг 6: Хранение в базе данных
11. Шаг 7: Дашборд на FastAPI
12. Шаг 8: Планирование и автоматизация
13. Шаг 9: Мониторинг и анти-детект
14. Шаг 10: Деплой
15. Продвинутые возможности
16. Решение проблем

1. Что вы построите

К концу этого туториала у вас будет:

+=====================================================================+
|                 ВОЗМОЖНОСТИ СИСТЕМЫ                                  |
+=====================================================================+
|                                                                       |
|  [x] Парсинг комментариев из любой публичной группы Telegram        |
|  [x] Классификация лидов через GPT-4o-mini (88-91% точность)       |
|  [x] Автоответ HOT лидам в течение 60 секунд                       |
|  [x] Хранение всех лидов в PostgreSQL с полной историей             |
|  [x] Дашборд для просмотра, фильтрации и экспорта лидов             |
|  [x] Мульти-аккаунт поддержка (ротация сессий)                      |
|  [x] Анти-детект (лимиты, ротация прокси)                           |
|  [x] Последовательности follow-up (5-шаговая автоматизация)         |
|  [x] REST API для интеграции с CRM                                  |
|  [x] Docker деплой (одна команда для запуска)                        |
|                                                                       |
+=====================================================================+

Разбор стоимости

Общая месячная стоимость:
VPS (Hetzner CX22)           $4.50/мес
  OpenAI API (1000 лидов)      $0.03-0.05
  Домен (опционально)          $1/мес
  Прокси (опционально)         $5-10/мес
  ----------------------------------------
  ИТОГО                        $5.55-15.55/мес
Потенциальная выручка:       $5 000-50 000/мес
  ROI:                         30 000-900 000%

2. Обзор архитектуры

+=====================================================================+
|                 АРХИТЕКТУРА СИСТЕМЫ                                   |
+=====================================================================+
|                                                                       |
|  +-------------------+     +-------------------+                    |
|  |   Telegram API    |     |   OpenAI API      |                    |
|  |   (Telethon)      |     |   (GPT-4o-mini)   |                    |
+---------+---------+     +---------+---------+
v                         v
+-------------------+     +-------------------+
Парсер
Классификатор
Воркер
Воркер
+---------+---------+     +---------+---------+
+------------+------------+
v
+-------------------+
PostgreSQL
База данных
+---------+---------+
+------------+------------+
v                         v
+-------------------+     +-------------------+
Автоответ
Дашборд
Бот
(FastAPI)
+-------------------+     +-------------------+
+=====================================================================+

3. Требования

Обязательные:
  [x] Python 3.11+
  [x] Аккаунт Telegram (номер телефона)
  [x] API ключ OpenAI (или другой LLM провайдер)
  [x] PostgreSQL база данных
Опциональные:
  [ ] VPS сервер (для 24/7 работы)
  [ ] Сервис прокси (для мульти-аккаунта)
  [ ] Домен (для дашборда)
  [ ] Docker (для простого деплоя)
Время выполнения: 4-6 часов
Сложность: Средняя

4. Настройка проекта

Создание структуры

mkdir tg-lead-gen && cd tg-lead-gen
python -m venv venv
source venv/bin/activate
mkdir -p app/{scraper,classifier,bot,api,db}
touch app/__init__.py

Установка зависимостей

cat > requirements.txt << EOF
telethon==1.36.0
openai==1.50.0
asyncpg==0.30.0
fastapi==0.115.0
uvicorn==0.32.0
pydantic==2.9.0
apscheduler==3.10.4
python-dotenv==1.0.1
httpx==0.27.0
EOF
pip install -r requirements.txt

Конфигурация окружения

cat > .env << EOF
TG_API_ID=your_api_id
TG_API_HASH=your_api_hash
OPENAI_API_KEY=sk-your-api-key
DATABASE_URL=postgresql://user:password@localhost:5432/leadgen
AUTO_REPLY_ENABLED=true
MAX_REPLIES_PER_HOUR=30
CLASSIFICATION_MODEL=gpt-4o-mini
EOF

5. Шаг 1: Сессии аккаунтов Telegram

Генератор сессий

# app/session_generator.py
import asyncio
from telethon import TelegramClient
from telethon.sessions import StringSession
import os
from dotenv import load_dotenv
load_dotenv()
API_ID = int(os.getenv("TG_API_ID"))
API_HASH = os.getenv("TG_API_HASH")
async def create_session(account_name: str = "default"):
    client = TelegramClient(StringSession(), API_ID, API_HASH)
    await client.start()
    
    session_string = client.session.save()
    
    os.makedirs("sessions", exist_ok=True)
    with open(f"sessions/{account_name}.session", "w") as f:
        f.write(session_string)
    
    me = await client.get_me()
    print(f"Сессия создана для: {me.first_name} (@{me.username})")
    
    await client.disconnect()
    return session_string
if __name__ == "__main__":
    asyncio.run(create_session("account_1"))

6. Шаг 2: Поиск и вступление в группы

Поиск групп

# app/scraper/discovery.py
import asyncio
from telethon import TelegramClient
from telethon.tl.functions.contacts import SearchRequest
async def search_groups(client: TelegramClient, query: str, limit: int = 50):
    result = await client(SearchRequest(q=query, limit=limit))
    
    groups = []
    for chat in result.chats:
        if hasattr(chat, "megagroup") and chat.megagroup:
            groups.append({
                "id": chat.id,
                "title": chat.title,
                "username": chat.username,
                "members": getattr(chat, "participants_count", 0),
                "type": "group"
            })
    return groups
async def join_group(client: TelegramClient, group_username: str):
    try:
        entity = await client.get_entity(group_username)
        await client.join_chat(entity)
        print(f"Вступил: {group_username}")
        return True
    except Exception as e:
        print(f"Ошибка вступления в {group_username}: {e}")
        return False

7. Шаг 3: Парсинг комментариев через Telethon

Основной класс парсера

# app/scraper/scrapers.py
import asyncio
import logging
from datetime import datetime, timedelta
from telethon import TelegramClient
from dataclasses import dataclass
logger = logging.getLogger(__name__)
@dataclass
class Comment:
    user_id: int
    username: str | None
    first_name: str | None
    last_name: str | None
    text: str
    date: datetime
    group_id: int
    group_name: str
    post_id: int
    message_id: int
    has_phone: bool = False
@dataclass
class ScrapedPost:
    post_id: int
    text: str
    date: datetime
    views: int
    comments_count: int
    group_id: int
    group_name: str
    comments: list[Comment]
class GroupScraper:
    def __init__(self, client: TelegramClient):
        self.client = client
    
    async def scrape_group(self, group_entity, limit: int = 100, days_back: int = 7):
        posts = []
        cutoff = datetime.now() - timedelta(days=days_back)
        
        entity = await self.client.get_entity(group_entity)
        
        async for message in self.client.iter_messages(entity, limit=limit):
            if message.date < cutoff:
                break
            if not message.text:
                continue
            
            comments = []
            if message.replies and message.replies.replies > 0:
                comments = await self._fetch_comments(entity, message)
            
            post = ScrapedPost(
                post_id=message.id,
                text=message.message or "",
                date=message.date,
                views=message.views or 0,
                comments_count=message.replies.replies if message.replies else 0,
                group_id=entity.id,
                group_name=entity.title,
                comments=comments
            )
            posts.append(post)
        
        return posts
    
    async def _fetch_comments(self, entity, message):
        comments = []
        async for reply in self.client.iter_messages(entity, reply_to=message.id, limit=200):
            if not reply.text:
                continue
            
            sender = None
            try:
                sender = await reply.get_sender()
            except Exception:
                pass
            
            comment = Comment(
                user_id=reply.sender_id,
                username=getattr(sender, "username", None) if sender else None,
                first_name=getattr(sender, "first_name", None) if sender else None,
                last_name=getattr(sender, "last_name", None) if sender else None,
                text=reply.text,
                date=reply.date,
                group_id=entity.id,
                group_name=entity.title,
                post_id=message.id,
                message_id=reply.id,
            )
            comments.append(comment)
        return comments

8. Шаг 4: ИИ-классификация лидов

Классификатор с поуровневым подходом

# app/classifier/ai_classifier.py
import re
import json
import logging
from openai import AsyncOpenAI
from dataclasses import dataclass
from enum import Enum
import os
logger = logging.getLogger(__name__)
class Intent(Enum):
    HOT = "HOT"
    WARM = "WARM"
    COLD = "COLD"
    SPAM = "SPAM"
@dataclass
class Classification:
    intent: Intent
    confidence: float
    topic: str
    sentiment: str
    action: str
    reason: str
    tier: str
HOT_PATTERNS = [
    r"(?i)(где купить|how to buy|where to buy)",
    r"(?i)(сколько стоит|how much|price|цена|стоимость)",
    r"(?i)(скидка|discount|акция|промокод|promo)",
    r"(?i)(купить|buy|purchase|заказать|order)",
    r"(?i)(демо|demo|trial|пробн|тест)",
    r"(?i)(связаться|contact|написать|write to)",
]
SPAM_PATTERNS = [
    r"(?i)(спам|spam|реклама|advertis)",
    r"(?i)(заработай|earn money|quick money|быстрые деньги)",
    r"(?i)(взлом|hack|crack)",
]
COLD_PATTERNS = [
    r"(?i)(спасибо|thank|thanks|благодарю)",
    r"(?i)(подписал|subscrib|follow)",
]
def classify_regex(text: str):
    for pattern in HOT_PATTERNS:
        if re.search(pattern, text):
            return Classification(Intent.HOT, 0.85, "buying_intent", "neutral", "reply", "Pattern match: buying intent", "regex")
    for pattern in SPAM_PATTERNS:
        if re.search(pattern, text):
            return Classification(Intent.SPAM, 0.90, "spam", "negative", "ignore", "Pattern match: spam", "regex")
    for pattern in COLD_PATTERNS:
        if re.search(pattern, text):
            return Classification(Intent.COLD, 0.80, "acknowledgment", "positive", "ignore", "Pattern match: cold", "regex")
    return None
CLASSIFY_PROMPT = """Вы - классификатор лидов для B2B SaaS компании.
Проанализируйте этот Telegram-комментарий и классифицируйте его.
Комментарий: "{comment}"
Группа: {group_name}
Тема поста: {post_topic}
Верните ТОЛЬКО JSON объект:
{{
    "intent": "HOT" | "WARM" | "COLD" | "SPAM",
    "confidence": 0.0-1.0,
    "topic": "краткая тема комментария",
    "sentiment": "позитивный" | "нейтральный" | "негативный",
    "action": "ответить" | "экспортировать" | "игнорировать",
    "reason": "объяснение в одно предложение"
}}
Правила классификации:
HOT: Явное намерение покупки, спрашивает цену/демо/детали/контакт

WARM: Проявляет интерес, но нет явного сигнала покупки

COLD: Гeneric комментарий, нет явного намерения

SPAM: Нерелевантный, рекламный бот, токсичный контент"""


async def classify_ai(text: str, group_name: str = "", post_topic: str = "", model: str = "gpt-4o-mini"):
    client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    
    prompt = CLASSIFY_PROMPT.format(
        comment=text[:500],
        group_name=group_name,
        post_topic=post_topic
    )
    
    response = await client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        temperature=0.1,
        max_tokens=300
    )
    
    result_text = response.choices[0].message.content.strip()
    result_text = re.sub(r"

<a name="auto-reply"></a>
9. Шаг 5: Бот автоответов

Шаблоны сообщений

<a name="database"></a>
10. Шаг 6: Хранение в базе данных

Схема

<a name="dashboard"></a>
11. Шаг 7: Дашборд на FastAPI

API эндпоинты

<a name="scheduling"></a>
12. Шаг 8: Планирование и автоматизация

Планировщик задач

<a name="monitoring"></a>
13. Шаг 9: Мониторинг и анти-детект

Ограничитель скорости

<a name="deployment"></a>
14. Шаг 10: Деплой

Docker Compose

Запуск

<a name="advanced"></a>
15. Продвинутые возможности

Последовательности follow-up

<a name="troubleshooting"></a>
16. Решение проблем

Типичные проблемы

Советы по производительности

Заключение

Теперь у вас есть полноценная, production-ready система генерации лидов в Telegram.

Начните строить сегодня. Лиды ждут.

Этот туториал является частью документации 24go.site.
Последнее обновление: сентябрь 2026.