напиши мне инвайтер для группы телеграм

Конечно! Ниже — готовые варианты инвайта для группы в Telegram. Выбирайте и подставьте ссылку/название. Могу дописать под вашу тему (о чём группа, кто аудитория, тон).

1) Коротко и по-делу

Присоединяйтесь к [Название группы] — обсуждаем [тема], делимся опытом и полезностями каждый день. Ждём вас 👉 [ссылка]

2) Дружелюбно

Привет! Если вам близка тема [тема], приходите в нашу уютную группу [Название]. Без спама, только практика, ответы на вопросы и живое общение. Вход здесь: [ссылка]

3) С пользой (упор на ценность)

В [Название группы] вы получите:
• чек-листы и гайды по [тема]
• разборы кейсов каждую неделю
• ответы на вопросы от участников
Подключайтесь: [ссылка]

4) Деловой стиль

Приглашаем в профессиональное сообщество [Название] по [тема]. Стандарты, лучшие практики, обмен опытом и нетворкинг. Присоединиться: [ссылка]

5) Динамично/маркетингово

Хватит листать — пора прокачать [тема] вместе с нами! В [Название]: быстрые советы, разборы, встречи и поддержка единомышленников. Жми: [ссылка] 🚀

6) Для закрытой/камерной группы

Открываем доступ в маленький закрытый круг по [тема]. Акцент на практику, фидбек и взаимопомощь. Если вам по пути — заходите: [ссылка] (мест немного)

7) С призывом к первому действию

Сегодня в [Название] разбираем [конкретная тема/вопрос]. Хотите участвовать и получить материалы? Подключайтесь сейчас: [ссылка]

---

Советы по оформлению:

• Укажите чёткий бенефит в 1–2 строках (что человек получит в ближайшую неделю).
• Добавьте социальное доказательство: «уже 350+ участников», «кейсы каждую пятницу».
• Один призыв к действию и одна ссылка — без лишнего.
• Если группа модераторская — пропишите правила в 1 строке («без рекламы, только по теме»).

Если подскажете: тематику, аудиторию, тон (дружелюбный/строгий/игровой), и ключевые преимущества, я соберу один точный инвайт под вашу группу.

Ниже два основных варианта «инвайтера» на Python — для личного аккаунта через Telethon и для бота через библиотеку python-telegram-bot. Выберите тот, который подходит под ваши права и задачи.

---

1. Скрипт на Telethon (добавление участников напрямую)

Требуется: личный аккаунт-админ в целевой группе (+ право Invite Users), api_id/api_hash с my.telegram.org и файл users.csv со списком юзернеймов.

python
import asyncio, csv
from telethon import TelegramClient
from telethon.tl.functions.channels import InviteToChannelRequest

API_ID = 123456          # ваше api_id
API_HASH = "YOUR_API_HASH"
SESSION = "inviter"      # имя .session-файла
TARGET = "https://t.me/+XXXXXXXXXXXX"  # @username или приватная ссыл­ка группы

BATCH_SIZE = 5           # приглашать по N человек за раз
PAUSE = 10               # сек между пачками (уменьшает FloodWait)

async def main():
    client = TelegramClient(SESSION, API_ID, API_HASH)
    await client.start()

    channel = await client.get_entity(TARGET)

    users = []
    with open("users.csv") as f:
        for row in csv.reader(f):
            try:
                users.append(await client.get_input_entity(row[0].strip()))
            except Exception as e:
                print("Пропуск", row[0], "→", e)

    for i in range(0, len(users), BATCH_SIZE):
        batch = users[i:i+BATCH_SIZE]
        try:
            await client(InviteToChannelRequest(channel, batch))
            print(f"➕ Добавлено {len(batch)}")
        except Exception as e:
            print("Flood/ошибка:", e)
            await asyncio.sleep(60)          # переждать FloodWait
        await asyncio.sleep(PAUSE)

    await client.disconnect()

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

Как это работает

1. Подключаемся по api_id/api_hash и создаём (или переиспользуем) .session.
2. Берём целевую группу как channel-entity.
3. Читаем CSV, резолвим каждого юзера в InputUser.
4. Отправляем пачкой через InviteToChannelRequest — именно этот RPC отвечает за приглашение в чаты/каналы. (tl.telethon.dev)
5. Делаем паузы, чтобы не словить FloodWait. Документация Telethon отдельно предупреждает, что «массовое добавление может привести к лимитам/блокировке» — действуйте аккуратно. (docs.telethon.dev)

---

2. Инвайтер-бот (создаёт персональные ссылки)

Подойдёт, если у вас бот-админ и вы не хотите «насильно» добавлять людей, а предпочитаете отправлять им ссылку-приглашение.

python
from telegram import Bot

BOT_TOKEN = "YOUR_BOT_TOKEN"
CHAT_ID   = -1001234567890   # ID супер-группы или канала
USER_ID   = 987654321        # кому отправляем ссылку

bot = Bot(BOT_TOKEN)

# создаём одноразовую ссылку со сроком действия 1 день и лимитом 1
invite = bot.create_chat_invite_link(
    chat_id=CHAT_ID,
    expire_date=int(time.time()) + 86400,
    member_limit=1,
    creates_join_request=False,
)

bot.send_message(USER_ID, f"Присоединяйтесь: {invite.invite_link}")

Метод create_chat_invite_link (Bot API 9.1) генерирует ссылку; затем бот отправляет её пользователю любым удобным способом. (Telegram)

---

Полезные советы

Что учесть	Почему важно
Право invite	Аккаунт/бот должен иметь право приглашать участников.
FloodWait	Telegram вводит паузу при массе инвайтов; ловите исключение и ждите указанное время.
Лимиты	В сутки ≈ 50 «жёстких» инвайтов на аккаунт; ссылки через бота менее ограничены.
GDPR и спам	Убедитесь, что у вас есть согласие пользователей; иначе аккаунт рискует получить лимит.
Логи	Пишите в консоль или файл, кто успешно добавлен, кто нет.

Если нужен разбор под ваш конкретный кейс (как формировать CSV, обработка FloodWait, прокси, Docker и т. д.) — напишите детали, дополним скрипт.

Ниже — расширенный «мощный» инвайтер на Python.
Вкратце: скрипт умеет работать с несколькими аккаунтами Telethon, автоматически ловит Flood-Wait/PeerFlood ошибки, дозирует приглашения (по умолчанию ≤ 50 в сутки на аккаунт, что соответствует текущим лимитам Telegram), поддерживает прокси, паузы и логирование. Он не обход​ит официальные ограничения — это невозможно — но помогает использовать их максимально эффективно и безопасно. (docs.telethon.dev, Stack Overflow, GitHub, telethon-01914.readthedocs.io, Pyrogram, Virtual User Software, ITGeared, Stack Overflow, tl.telethon.dev, limits.tginfo.me)

---

1. Что делает «мощный» инвайтер

Возможность	Зачем нужна
Ротация нескольких аккаунтов	Каждому пользователю разрешено пригласить ~50 человек в сутки; переключение аккаунтов повышает общий лимит. (ITGeared, Virtual User Software)
Обработка FloodWaitError / PeerFloodError	Telegram выдаёт таймауты вплоть до нескольких часов; скрипт автоматически ждёт нужное время и продолжает. (Stack Overflow, GitHub)
Регулируемые паузы и семафор	Даже без ошибок API стоит ограничивать частоту запросов (рекомендуется ≥ 5–10 с между батчами). (Pyrogram, Stack Overflow)
Прокси и перезапуск	Позволяет работать из-за фаерволлов и снижать шанс блокировки IP.
Асинхронность asyncio	Конкурентно обслуживает десятки аккаунтов, не блокируя CPU. (docs.telethon.dev, Stack Overflow)

---

2. Подготовка

bash
pip install telethon==1.40 PyYAML tqdm

1. Создайте API-пару (api_id, api_hash) для каждого аккаунта на my.telegram.org и войдите через telethon (появятся <session>.session файлы).
2. Создайте config.yaml:

yaml
target: "https://t.me/+XXXXXXXXXXX"  # цель (публичный @username или пригласительная ссылка)
batch_size: 5                        # сколько юзеров за раз
pause: 8                             # секунд между пачками
accounts:
  - session: "acc1"
  - session: "acc2"
  - session: "acc3"
proxy:                               # при необходимости
  host: "127.0.0.1"
  port: 1080
  username: "user"
  password: "pass"

3. Подготовьте users.csv — список username/ID/чат-invite-ссылок.

---

3. Скрипт inviter.py

python
import asyncio, csv, yaml, logging, time
from pathlib import Path
from typing import List
from functools import wraps

from telethon import TelegramClient, errors, functions
from telethon.errors import FloodWaitError, PeerFloodError
from telethon.sessions import StringSession
from tqdm.asyncio import tqdm_asyncio

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(name)s | %(levelname)s | %(message)s",
)

def retry_flood(func):
    """Декоратор: пережидает FloodWait/PeerFlood и повторяет."""
    @wraps(func)
    async def wrapper(*args, **kwargs):
        while True:
            try:
                return await func(*args, **kwargs)
            except (FloodWaitError, errors.FloodWaitError) as e:
                wait = e.seconds + 5
                logging.warning("⏳ FloodWait %s сек – ждём.", wait)
                await asyncio.sleep(wait)
            except PeerFloodError as e:
                logging.error("🚫 PeerFlood: %s – пригласительный лимит исчерпан.", e)
                raise
    return wrapper

class Inviter:
    def __init__(self, cfg: dict):
        self.cfg = cfg
        self.semaphore = asyncio.Semaphore(1)  # 1 аккаунт приглашает одновременно
        self.clients: List[TelegramClient] = []

    async def __aenter__(self):
        proxy = None
        if self.cfg.get("proxy"):
            proxy = (
                self.cfg["proxy"]["host"],
                self.cfg["proxy"]["port"],
                self.cfg["proxy"]["username"],
                self.cfg["proxy"]["password"],
            )
        for acc in self.cfg["accounts"]:
            client = TelegramClient(
                session=acc["session"],
                api_id=acc.get("api_id"),
                api_hash=acc.get("api_hash"),
                proxy=proxy,
            )
            await client.start()
            self.clients.append(client)
        return self

    async def __aexit__(self, exc_type, exc, tb):
        for c in self.clients:
            await c.disconnect()

    @retry_flood
    async def invite_batch(self, client: TelegramClient, channel, batch):
        await client(functions.channels.InviteToChannelRequest(channel, batch))

    async def process_account(self, client: TelegramClient, users):
        channel = await client.get_entity(self.cfg["target"])
        for i in range(0, len(users), self.cfg["batch_size"]):
            batch = users[i : i + self.cfg["batch_size"]]
            async with self.semaphore:
                await self.invite_batch(client, channel, batch)
                logging.info("✅ %s: добавлено %s", client.session.filename, len(batch))
            await asyncio.sleep(self.cfg["pause"])

    async def run(self):
        users = []
        with open("users.csv") as f:
            for row in csv.reader(f):
                users.append(row[0].strip())
        # делим пользователей между аккаунтами
        chunks = [users[i::len(self.clients)] for i in range(len(self.clients))]
        await tqdm_asyncio.gather(
            *[self.process_account(c, chunk) for c, chunk in zip(self.clients, chunks)]
        )

async def main():
    cfg = yaml.safe_load(Path("config.yaml").read_text())
    async with Inviter(cfg) as inviter:
        await inviter.run()

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

Почему так:

• retry_flood ловит оба типа ошибок и ждёт e.seconds + 5 с. Telegram сам сообщает точное число секунд, которое необходимо выждать. (Stack Overflow, GitHub)
• Семафор self.semaphore гарантирует, что в моменте приглашает только один аккаунт, снижая суммарный RPS.
• Пользователи делятся между аккаунтами циклически users[i::len(self.clients)], чтобы нагрузка распределялась равномерно.
• batch_size = 5 и pause = 8 с — стартовые параметры; поправьте, если ваши аккаунты «возрастные» и Telegram разрешает больше. (fbsee.com, Virtual User Software)

---

4. Запуск

bash
python inviter.py

Логи будут вида:

text
2025-08-02 12:34:01 | root | INFO | ✅ acc1.session: добавлено 5
2025-08-02 12:34:10 | root | WARNING | ⏳ FloodWait 32 сек – ждём.

---

5. Практические рекомендации

1. Новые аккаунты приглашайте очень осторожно — начните с 10-20 пользователей в день; Telegram усиливает лимиты для «молодых» аккаунтов. (fbsee.com)
2. Не приглашайте людей без их согласия — массовые жалобы приведут к PEER_FLOOD и ограничат аккаунт насовсем. (tl.telethon.dev)
3. Следите за суммой пригласительных ссылок. Если хотите избегать «жёстких» инвайтов, генерируйте ChatInviteLink через бота и рассылайте приватно; лимитов там меньше. (Python Telegram Bot)
4. Прокси нужен только в странах с блокировкой Telegram или при большой распределённой нагрузке.
5. Обновляйте Telethon: каждое крупное обновление API вносит новые коды ошибок.

---

6. Что ещё можно добавить

Опция	Идея реализации
Капча-распознавание	При логине иногда приходит «captcha»; можно интегрировать RuCaptcha/2Captcha.
БД-учёт	Сохранять, кого уже пригласили, в SQLite или Redis, чтобы не дублировать.
Автопринятие join-request	Для request-only групп можно парсить UpdateChatJoinRequest и одобрять.

С этим шаблоном вы получаете полнофункциональный, устойчивый к FloodWait, много-аккаунтный инвайтер на Python, соответствующий актуальным ограничениям Telegram по состоянию на август 2025 г.

Ошибка означает, что в момент создания TelegramClient(...) библиотека получила пустые (None/пустая строка) значения для api_id и/или api_hash. По документации Telethon эти параметры обязательны при создании клиента (они не «берутся из .session») — их нужно передать каждый раз, когда вы создаёте TelegramClient. (docs.telethon.dev, docs.telethon.dev)

Ниже — как быстро исправить.

---

1) Проверьте config.yaml

В вашем «мощном инвайтере» клиент создаётся так:

python
client = TelegramClient(
    session=acc["session"],
    api_id=acc.get("api_id"),      # <- здесь у вас выходит None
    api_hash=acc.get("api_hash"),  # <- и здесь None
    proxy=proxy,
)

А в примере config.yaml я не добавил api_id/api_hash (моя недосмотренность), поэтому acc.get(...) возвращает None, и Telethon бросает ValueError. Исправьте конфиг одним из способов:

Вариант А: один api_id/api_hash на все аккаунты

yaml
api_id: 123456
api_hash: "abcd1234abcd1234abcd1234abcd1234"

target: "https://t.me/+XXXXXXXXXXX"
batch_size: 5
pause: 8

accounts:
  - session: "acc1"
  - session: "acc2"
  - session: "acc3"

Вариант Б: пара на каждый аккаунт

yaml
target: "https://t.me/+XXXXXXXXXXX"
batch_size: 5
pause: 8

accounts:
  - session: "acc1"
    api_id: 111111
    api_hash: "hash_for_acc1"
  - session: "acc2"
    api_id: 222222
    api_hash: "hash_for_acc2"

Примечание: Телеграм требует api_id/api_hash («приложение») при использовании MTProto. Получить их можно на my.telegram.org → API development tools (это официальный способ). (Telegram)

---

2) Исправьте код, чтобы была «подстраховка»

Сделайте глобальные значения из конфига дефолтными для каждого аккаунта и проверьте, что они не пустые:

python
# внутри __aenter__ или перед созданием клиента
global_api_id = self.cfg.get("api_id")
global_api_hash = self.cfg.get("api_hash")

for acc in self.cfg["accounts"]:
    api_id = acc.get("api_id", global_api_id)
    api_hash = acc.get("api_hash", global_api_hash)

    if not api_id or not api_hash:
        raise ValueError("Missing api_id/api_hash: добавьте в config.yaml глобально или для аккаунта.")

    client = TelegramClient(
        session=acc["session"],
        api_id=int(api_id),
        api_hash=str(api_hash),
        # уберите proxy, если не настраивали его корректно
    )
    await client.start()
    self.clients.append(client)

Почему этого недостаточно просто «иметь .session»: по документации, файл сессии хранит ключ авторизации, кеш сущностей и т.п., но не заменяет необходимость передавать api_id/api_hash при создании клиента. (docs.telethon.dev)

---

3) Мини-проверка, что пара валидна

Создайте тестовый файл smoke.py:

python
from telethon import TelegramClient
api_id = 123456
api_hash = "abcd1234abcd1234abcd1234abcd1234"

with TelegramClient("test", api_id, api_hash) as client:
    me = client.loop.run_until_complete(client.get_me())
    print("OK:", me.id)

Если скрипт выводит ваш id — пара корректна и читается правильно. Сигнатура клиента требует именно эти аргументы (api_id, api_hash), это видно в официальной справке по TelegramClient. (docs.telethon.dev)

---

4) Где взять api_id/api_hash (если ещё нет)

1. Зайдите на https://my.telegram.org под вашим номером.
2. Откройте API development tools, заполните форму.
3. Сохраните выданные api_id и api_hash и пропишите их в config.yaml. (Telegram)

---

5) Частые причины этой ошибки

• Пустые переменные окружения или неправильно загружаемый .env (в Docker/cron это встречается часто: процесс не видит env). Симптом — в код приходит None, и вы видите именно это ValueError. (Stack Overflow)
• Опечатки в ключах YAML (apiId вместо api_id, и т.п.).
• Указали только session, но не указали api_id/api_hash (ваш случай).

---

Если пришлёте ваш config.yaml без секретов (замажьте числа/строки) и кусок кода создания клиента, проверю и подскажу точечно. Также, если вы используете бот-токен, он передаётся в client.start(bot_token=...), но api_id/api_hash всё равно нужны на этапе создания TelegramClient — это требование Telethon. (docs.telethon.dev)

Уточните, пожалуйста:

• вы хотите один api_id/api_hash для всех аккаунтов или разные?
• нужен ли вам proxy (если да — я подскажу корректный формат для PySocks/MTProto). (docs.telethon.dev)

Коротко: Telethon падает, когда вы передаёте строку-«юзернейм», которого нет — метод get_input_entity внутри клиента выбрасывает UsernameNotOccupiedError, который оборачивается в ValueError («No user has … as username») (Stack Overflow).
Самый надёжный способ «просто пропускать» такие строки — попытаться предварительно (!) резолвить каждого пользователя и игнорировать все исключения, которые означают «пользователь/канал не найден» (Stack Overflow, Stack Overflow). Затем в InviteToChannelRequest передавать только успешно полученные InputUser-объекты (метод требует именно их, а не строки) (Telethon API).

---

Почему возникает ошибка

Шаг	Что делает Telethon	Что идёт не так
Вы передаёте строку jdjzbkdj в InviteToChannelRequest.	Для каждой строки библиотека вызывает скрытый _get_entity_from_string (docs.telethon.dev).	Поскольку ни в кэше, ни в сети такого @username нет, Telegram API отвечает USERNAME_NOT_OCCUPIED (Stack Overflow).
Исключение UsernameNotOccupiedError оборачивается в ValueError со словами «No user has …».	Ваш цикл никак его не ловит — скрипт аварийно завершается на первой «битой» записи.

---

Патч: безопасное резолвинг-и-приглашение

Ниже минимальный diff (Python 3.8+).
Меняем только две функции: process_account и новую resolve_users.

python
from telethon.errors import (
    UsernameNotOccupiedError, UsernameInvalidError,
    UsernameNotModifiedError  # на всякий случай
)

async def resolve_users(client, usernames):
    """Вернуть список InputUser, пропустив всех 'битых'."""
    result = []
    for name in usernames:
        try:
            ent = await client.get_input_entity(name)
            result.append(ent)          # успех
        except (ValueError,
                UsernameNotOccupiedError,
                UsernameInvalidError,
                UsernameNotModifiedError) as e:
            logging.warning("⏭️  Пропуск '%s': %s", name, e)
        except Exception as e:
            # любые другие ошибки логируем, но не падаем
            logging.error("❗  Не смог обработать '%s': %s", name, e)
    return result

async def process_account(self, client: TelegramClient, users):
    channel = await client.get_entity(self.cfg["target"])
    users = await resolve_users(client, users)  # <-- новую функцию вызвали
    for i in range(0, len(users), self.cfg["batch_size"]):
        batch = users[i : i + self.cfg["batch_size"]]
        if not batch:
            continue
        async with self.semaphore:
            await self.invite_batch(client, channel, batch)
            logging.info("✅ %s: добавлено %s", client.session.filename, len(batch))
        await asyncio.sleep(self.cfg["pause"])

Что поменялось

1. Предварительное резолвинг

   • Для каждой строки пробуем get_input_entity (дешёвый вызов, кешируется).
   • Если юзернейм «битый», ловим исключение и 💬 пишем в лог, но не прерываем выполнение (Stack Overflow, GitHub).

2. В InviteToChannelRequest попадают только InputUser
   Это ровно то, что требует RPC-метод (Telethon API).

3. Семантика остальных ошибок сохраняется
   Для FloodWaitError и PeerFloodError по-прежнему срабатывает декоратор-ретрай (docs.telethon.dev). Другие исключения мы логируем, но не падаем.

---

Полный файл после правок

python
import asyncio, csv, yaml, logging
from pathlib import Path
from typing import List
from functools import wraps

from telethon import TelegramClient, errors, functions
from telethon.errors import (
    FloodWaitError, PeerFloodError,
    UsernameNotOccupiedError, UsernameInvalidError, UsernameNotModifiedError
)
from tqdm.asyncio import tqdm_asyncio

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)s | %(message)s",
)

def retry_flood(func):
    @wraps(func)
    async def wrapper(*args, **kwargs):
        while True:
            try:
                return await func(*args, **kwargs)
            except (FloodWaitError, errors.FloodWaitError) as e:
                wait = e.seconds + 5
                logging.warning("⏳ FloodWait %s сек — ждём.", wait)
                await asyncio.sleep(wait)
            except PeerFloodError as e:
                logging.error("🚫 PeerFlood: %s", e)
                raise
    return wrapper

class Inviter:
    def __init__(self, cfg: dict):
        self.cfg = cfg
        self.semaphore = asyncio.Semaphore(1)
        self.clients: List[TelegramClient] = []

    async def __aenter__(self):
        proxy = tuple(self.cfg["proxy"].values()) if self.cfg.get("proxy") else None
        for acc in self.cfg["accounts"]:
            client = TelegramClient(
                session=acc["session"],
                api_id=acc.get("api_id", self.cfg.get("api_id")),
                api_hash=acc.get("api_hash", self.cfg.get("api_hash")),
                proxy=proxy,
            )
            await client.start()
            self.clients.append(client)
        return self

    async def __aexit__(self, *exc):
        await asyncio.gather(*(c.disconnect() for c in self.clients))

    @retry_flood
    async def invite_batch(self, client, channel, batch):
        await client(functions.channels.InviteToChannelRequest(channel, batch))

    async def resolve_users(self, client, usernames):
        ok = []
        for name in usernames:
            try:
                ok.append(await client.get_input_entity(name))
            except (ValueError, UsernameNotOccupiedError,
                    UsernameInvalidError, UsernameNotModifiedError) as e:
                logging.warning("⏭️  Пропуск '%s': %s", name, e)
            except Exception as e:
                logging.error("❗  Неизвестно для '%s': %s", name, e)
        return ok

    async def process_account(self, client, users):
        channel = await client.get_entity(self.cfg["target"])
        users = await self.resolve_users(client, users)
        for i in range(0, len(users), self.cfg["batch_size"]):
            batch = users[i:i+self.cfg["batch_size"]]
            if not batch:
                continue
            async with self.semaphore:
                await self.invite_batch(client, channel, batch)
                logging.info("✅ %s: добавлено %d", client.session.filename, len(batch))
            await asyncio.sleep(self.cfg["pause"])

    async def run(self):
        with open("users.csv") as f:
            raw = [row[0].strip() for row in csv.reader(f) if row]
        chunks = [raw[i::len(self.clients)] for i in range(len(self.clients))]
        await tqdm_asyncio.gather(
            *(self.process_account(c, chunk) for c, chunk in zip(self.clients, chunks))
        )

async def main():
    cfg = yaml.safe_load(Path("config.yaml").read_text())
    async with Inviter(cfg) as inviter:
        await inviter.run()

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

---

Дополнительные советы

• Проверьте CSV: уберите пустые строки/символы «@».
• Ограничьте частоту: даже с пропуском ошибок, ⚠️ массовое добавление остаётся рискованным для аккаунта (Stack Overflow).
• Кэш-файлы Telethon: после первого успешного get_input_entity сущность кэшируется локально, поэтому повторные вызовы почти бесплатны (docs.telethon.dev).

Теперь «битые» имена будут просто логироваться и игнорироваться — скрипт пройдёт весь список до конца, не падая.

Новая ошибка возникает, когда в список «приглашаемых» попадает не человек, а канал/чат – у get_input_entity() получается объект InputPeerChannel, который InviteToChannelRequest принять не может, потому что этому RPC-методу нужны только элементы типа InputUser / InputPeerUser (tl.telethon.dev, docs.telethon.dev, GitHub).

Исправляем так:

1 – фильтруем сущности ещё до вызова InviteToChannelRequest

python
from telethon.tl import types  # импорт в начало файла

async def resolve_users(self, client, identifiers):
    """Возвращает только InputUser; все остальные сущности пропускаем."""
    ok = []
    for ident in identifiers:
        try:
            ent = await client.get_input_entity(ident)
            if isinstance(ent, (types.InputUser, types.InputPeerUser)):
                ok.append(ent)
            else:                         # канал, чат, бот-чат и т.п.
                logging.warning("⏭️  '%s' — это %s, пропуск.",
                                ident, ent.__class__.__name__)
        except (
            ValueError,
            UsernameNotOccupiedError,
            UsernameInvalidError,
            UsernameNotModifiedError,
        ) as e:
            logging.warning("⏭️  Пропуск '%s': %s", ident, e)
        except Exception as e:
            logging.error("❗  Неизвестно для '%s': %s", ident, e)
    return ok

Почему именно так

• InviteToChannelRequest принимает «users: Vector<InputUser>» — ничего кроме пользователей (tl.telethon.dev).
• get_input_entity() возвращает разные подклассы InputPeer*; нужно отсеять всё, что не …User (docs.telethon.dev).
• GitHub-issue-пример «users must be InputUser» подчёркивает ту же проблему (GitHub).

2 – обновляем process_account

python
async def process_account(self, client, raw_users):
    channel = await client.get_entity(self.cfg["target"])
    users = await self.resolve_users(client, raw_users)  # теперь фильтрован
    ...

3 – проверяем CSV

Частая причина ошибки — в users.csv случайно попадают:

• ссылки на каналы (https://t.me/+…, https://t.me/c/…),
• названия групп/чатов,
• usernames, которые уже превратились в канал после конвертации чата в супер-группу.

Оставьте в файле только usernames или ID реальных пользователей; можно с «@» — Telethon корректно понимает оба варианта (Stack Overflow).

4 – результат

После правки скрипт:

1. безопасно резолвит каждое имя;
2. логирует и пропускает каналы/невалидные юзеры;
3. Передаёт в InviteToChannelRequest только корректные InputUser-объекты, исключая TypeError: Cannot cast InputPeerChannel….

Теперь «мощный» инвайтер обходит обе категории ошибок:

• «пользователь не найден» (ValueError)
• «сущность ≠ пользователь» (TypeError).

При возникновении новых вопросов – пишите!