Telegram和Discord机器人代理：自动化操作指南（第一部分）

1. 基于全球流量的机器学习

Cloudflare利用精选的请求子集训练ML模型，为每个请求创建可靠的“机器人得分”（0-100）。得分越高，是机器人的可能性越大。

2. 新的HTTP/2和Client Hello启发式算法

自2025年6月起，Cloudflare通过HTTP/2指纹和TLS Client Hello扩展编写了50多个新的启发式算法。这使得即使使用无头浏览器，也能检测到自动化工具。

3. 个性化行为检测

Cloudflare利用模型为每个Bot Management客户提供行为异常检测，系统会学习特定站点的正常流量模式并识别偏差。

4. AI驱动的机器人和计算机视觉

现代抓取工具使用LLM进行语义理解，使用计算机视觉来解决视觉验证码。Cloudflare通过更复杂的挑战和模式检测来积极应对。

官方限制

• 私聊： 1条消息/秒（允许短暂爆发）
• 群组： 20条消息/分钟
• 全局： 每个机器人约30条消息/秒
• 群发： 每个用户约30个请求/秒
• 最大连接数： 100个并发连接

2025年新增： Telegram Bot API 7.1 引入了 allow_paid_broadcast 参数，允许通过 Telegram Stars 付费发送高达 1000条消息/秒。这是大规模群发解决方案。

关键限制

• 按IP地址： Discord会跟踪IP以检测多个机器人
• 按路由： 每个API端点都有自己的限制桶
• 全局速率限制： 所有端点每秒50个请求
• WebSocket： 每个分片每60秒120个事件

技术难点： discord.py 中的 WebSockets 不直接支持 HTTP 代理。需要使用 HTTPS 代理或 SOCKS5 等替代方案。

1. 指数退避 (Exponential backoff)

收到429错误时，指数级增加延迟：1秒 → 2秒 → 4秒 → 8秒。大多数库（python-telegram-bot, discord.py）都会自动实现这一点。

2. 通过代理分配负载

使用代理服务器池来分发负载。建议每100个请求/小时使用5-10个代理。

3. 请求队列

实现基于队列的架构，控制发送速度。这将有助于避免流量高峰。

4. 监控和适应

跟踪速率限制头信息 (X-RateLimit-Limit, X-RateLimit-Remaining)，并动态调整请求速度。

特点

用途： 自动回复器、通知、群组管理、群发
协议： HTTPS API 或 MTProto
速率限制： 严格（私聊1条/秒，群组20/分钟）

特点

用途： 版主管理、音乐、游戏、服务器分析
协议： REST API + WebSocket Gateway
速率限制： 按IP和路由限制，严格跟踪

特点

用途： 网站数据抓取、表单自动化、测试
协议： 通过无头浏览器进行 HTTP/HTTPS
检测： 非常高——指纹识别、验证码、行为分析

特点

用途： 管理多个社交媒体账户
协议： HTTPS API
检测： 按IP关联账户，设备指纹识别

🎁 促销代码 ARTHELLO —— 首次充值立享 +$1.3 优惠！

from telegram.ext import ApplicationBuilder
import httpx

# ProxyCove 代理配置
PROXY_URL = "http://username:password@proxy.proxycove.com:12345"

# 创建带代理的HTTP客户端
http_client = httpx.AsyncClient(
    proxy=PROXY_URL,
    timeout=30.0
)

# 使用代理初始化机器人
application = ApplicationBuilder() \
    .token("YOUR_BOT_TOKEN") \
    .get_updates_http_version("1.1") \
    .http_version("1.1") \
    .get_updates_request(httpx.Request(
        method="POST",
        url="https://api.telegram.org/bot{token}/getUpdates",
    )) \
    .build()

# 通过 request_kwargs 的替代方式
application = ApplicationBuilder() \
    .token("YOUR_BOT_TOKEN") \
    .request(httpx.AsyncClient(proxy=PROXY_URL)) \
    .build()

ProxyCove 建议： 对于Telegram机器人，请使用数据中心代理（$1.5/GB）。它们为API请求提供了出色的速度和稳定性。

const TelegramBot = require('node-telegram-bot-api');
const HttpsProxyAgent = require('https-proxy-agent');

// ProxyCove 代理配置
const proxyUrl = 'http://username:password@proxy.proxycove.com:12345';
const agent = new HttpsProxyAgent(proxyUrl);

// 使用代理初始化机器人
const bot = new TelegramBot('YOUR_BOT_TOKEN', {
  polling: true,
  request: {
    agent: agent,
    timeout: 30000
  }
});

// 消息处理
bot.on('message', (msg) => {
  const chatId = msg.chat.id;
  bot.sendMessage(chatId, '机器人正在通过代理运行！');
});

// 速率限制处理
bot.on('polling_error', (error) => {
  if (error.response && error.response.statusCode === 429) {
    console.log('超出速率限制，正在等待...');
    // 实现指数退避
  }
});

# Telethon
from telethon import TelegramClient
import socks

# SOCKS5 代理配置
proxy = (socks.SOCKS5, 'proxy.proxycove.com', 1080,
         True, 'username', 'password')

client = TelegramClient('session_name', api_id, api_hash,
                       proxy=proxy)

# Pyrogram
from pyrogram import Client

proxies = {
    "scheme": "socks5",  # "socks5", "http", "https"
    "hostname": "proxy.proxycove.com",
    "port": 1080,
    "username": "your_username",
    "password": "your_password"
}

app = Client("my_account",
             api_id=api_id,
             api_hash=api_hash,
             proxy=proxies)

警告： Userbots（通过用户账户操作）违反了Telegram的服务条款，可能导致账户被封禁。请自行承担风险，仅用于合法目的（自动化您自己的账户）。

import asyncio
from telegram.error import RetryAfter, TimedOut

async def send_with_retry(bot, chat_id, text, max_retries=3):
    """带自动重试的消息发送功能"""
    for attempt in range(max_retries):
        try:
            return await bot.send_message(chat_id, text)
        except RetryAfter as e:
            # Telegram 告知了精确的等待时间
            wait_time = e.retry_after
            print(f"速率限制：等待 {wait_time} 秒")
            await asyncio.sleep(wait_time)
        except TimedOut:
            # 连接超时
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # 指数退避
                await asyncio.sleep(wait_time)
            else:
                raise

    raise Exception("超出最大重试次数")

# 使用方法
await send_with_retry(bot, chat_id, "你好！")

import discord
from discord.ext import commands
import aiohttp

# ProxyCove HTTPS 代理配置 (HTTP 不适用于 WebSocket!)
PROXY_URL = "https://username:password@proxy.proxycove.com:443"

# 创建带代理的连接器
connector = aiohttp.TCPConnector()

# 初始化机器人
intents = discord.Intents.default()
intents.message_content = True

bot = commands.Bot(
    command_prefix='!',
    intents=intents,
    proxy=PROXY_URL,
    connector=connector
)

@bot.event
async def on_ready():
    print(f'{bot.user} 已通过代理连接！')

# 运行机器人
bot.run('YOUR_BOT_TOKEN')

重要提示： Discord 要求使用 HTTPS 或 SOCKS5 代理才能使 WebSocket 工作。普通的 HTTP 代理将无法工作！ProxyCove 提供所有必需的代理类型。

const { Client, GatewayIntentBits } = require('discord.js');
const { HttpsProxyAgent } = require('https-proxy-agent');

// 代理配置
const proxyUrl = 'http://username:password@proxy.proxycove.com:12345';
const agent = new HttpsProxyAgent(proxyUrl);

// 创建客户端
const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
  rest: {
    agent: agent
  },
  ws: {
    agent: agent
  }
});

client.on('ready', () => {
  console.log(`${client.user.tag} 已通过代理连接！`);
});

client.on('messageCreate', message => {
  if (message.content === '!ping') {
    message.reply('Pong 通过代理!');
  }
});

client.login('YOUR_BOT_TOKEN');

代理分配策略

• 1 机器人 = 1 专用IP——最大限度减少检测风险
• IPv6 住宅代理——干净的池，低延迟
• 粘性会话——至少30分钟，以保持稳定的WebSocket连接
• 地理分布——来自不同地区的机器人
• 轮换计划——每24-48小时更换一次IP

# 示例：机器人集群的代理管理器
import asyncio
import random

class ProxyManager:
    def __init__(self, proxy_list):
        """
        proxy_list: ProxyCove 代理列表
        [
            "http://user:pass@proxy1.proxycove.com:12345",
            "http://user:pass@proxy2.proxycove.com:12346",
            ...
        ]
        """
        self.proxies = proxy_list
        self.assigned = {}  # bot_id -> proxy

    def assign_proxy(self, bot_id):
        """为机器人分配唯一的代理"""
        if bot_id not in self.assigned:
            # 选择一个未使用的代理
            used = set(self.assigned.values())
            available = [p for p in self.proxies if p not in used]

            if not available:
                raise Exception("代理数量不足以分配给所有机器人")

            self.assigned[bot_id] = random.choice(available)

        return self.assigned[bot_id]

    async def rotate_proxy(self, bot_id):
        """为机器人轮换代理（每24-48小时）"""
        if bot_id in self.assigned:
            old_proxy = self.assigned[bot_id]
            # 选择一个新的代理
            new_proxy = random.choice(
                [p for p in self.proxies if p != old_proxy]
            )
            self.assigned[bot_id] = new_proxy
            return new_proxy

# 使用方法
proxies = [
    "http://user:pass@proxy1.proxycove.com:12345",
    "http://user:pass@proxy2.proxycove.com:12346",
    "http://user:pass@proxy3.proxycove.com:12347",
]

manager = ProxyManager(proxies)

# 为每个机器人分配
bot1_proxy = manager.assign_proxy("bot_1")
bot2_proxy = manager.assign_proxy("bot_2")

ProxyCove 推荐： 对于 Discord 机器人集群，请使用住宅代理（$2.7/GB）配合粘性会话。这将确保稳定的 WebSocket 连接并最大限度地减少封锁风险。

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service

# ProxyCove 代理配置
PROXY = "proxy.proxycove.com:12345"
PROXY_USER = "your_username"
PROXY_PASS = "your_password"

# 创建 Chrome 选项
chrome_options = Options()

# 基础隐身设置
chrome_options.add_argument('--disable-blink-features=AutomationControlled')
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

# 设置代理服务器
chrome_options.add_argument(f'--proxy-server={PROXY}')

# 对于带认证的代理，需要使用扩展程序
import zipfile
import os

def create_proxy_extension(proxy_host, proxy_port,
                          proxy_user, proxy_pass):
    """创建带认证的Chrome代理扩展"""
    manifest_json = """
    {
        "version": "1.0.0",
        "manifest_version": 2,
        "name": "Chrome Proxy",
        "permissions": [
            "proxy",
            "tabs",
            "unlimitedStorage",
            "storage",
            "",
            "webRequest",
            "webRequestBlocking"
        ],
        "background": {
            "scripts": ["background.js"]
        },
        "minimum_chrome_version":"22.0.0"
    }
    """

    background_js = f"""
    var config = {{
            mode: "fixed_servers",
            rules: {{
              singleProxy: {{
                scheme: "http",
                host: "{proxy_host}",
                port: parseInt({proxy_port})
              }},
              bypassList: ["localhost"]
            }}
          }};

    chrome.proxy.settings.set({{value: config, scope: "regular"}},
                              function() {{}});

    function callbackFn(details) {{
        return {{
            authCredentials: {{
                username: "{proxy_user}",
                password: "{proxy_pass}"
            }}
        }};
    }}

    chrome.webRequest.onAuthRequired.addListener(
                callbackFn,
                {{urls: [""]}},
                ['blocking']
    );
    """

    plugin_file = 'proxy_auth_plugin.zip'
    with zipfile.ZipFile(plugin_file, 'w') as zp:
        zp.writestr("manifest.json", manifest_json)
        zp.writestr("background.js", background_js)

    return plugin_file

# 创建扩展
proxy_host, proxy_port = PROXY.split(':')
extension = create_proxy_extension(
    proxy_host, proxy_port, PROXY_USER, PROXY_PASS
)

chrome_options.add_extension(extension)

# 启动驱动
driver = webdriver.Chrome(options=chrome_options)

# 附加：修改webdriver属性
driver.execute_script(
    "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
)

# 使用
driver.get('https://httpbin.org/ip')
print(driver.page_source)

driver.quit()
os.remove(extension)  # 删除临时扩展

from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.common.proxy import Proxy, ProxyType

# 代理配置
PROXY_HOST = "proxy.proxycove.com"
PROXY_PORT = 12345

# 创建带代理的Firefox配置文件
firefox_options = Options()

# 设置代理
firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.http", PROXY_HOST)
firefox_options.set_preference("network.proxy.http_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.ssl", PROXY_HOST)
firefox_options.set_preference("network.proxy.ssl_port", PROXY_PORT)

# 认证（需要额外的扩展）
# 替代方案：使用 SOCKS5 且不带认证

# 隐身设置
firefox_options.set_preference("dom.webdriver.enabled", False)
firefox_options.set_preference('useAutomationExtension', False)

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

# pip install selenium-stealth
from selenium import webdriver
from selenium_stealth import stealth

# 设置驱动（使用前面示例中的代理选项）
driver = webdriver.Chrome(options=chrome_options)

# 应用 stealth 技术
stealth(driver,
    languages=["ru-RU", "ru", "en-US", "en"],
    vendor="Google Inc.",
    platform="Win32",
    webgl_vendor="Intel Inc.",
    renderer="Intel Iris OpenGL Engine",
    fix_hairline=True,
)

# 现在机器人更难被检测
driver.get('https://bot.sannysoft.com/')  # 检测测试
# 检查结果——大多数测试应为绿色

driver.quit()

最佳实践： 将ProxyCove 住宅代理（$2.7/GB）与 selenium-stealth 和 User-Agent 轮换结合使用，以实现最大的隐蔽性。每 5-20 个请求轮换一次 IP。

const puppeteer = require('puppeteer');

(async () => {
  // ProxyCove 代理配置
  const PROXY = 'proxy.proxycove.com:12345';
  const PROXY_USER = 'your_username';
  const PROXY_PASS = 'your_password';

  // 启动带代理的浏览器
  const browser = await puppeteer.launch({
    headless: true,  // 生产环境设为 true，调试设为 false
    args: [
      `--proxy-server=${PROXY}`,
      '--no-sandbox',
      '--disable-setuid-sandbox',
      '--disable-dev-shm-usage',
      '--disable-accelerated-2d-canvas',
      '--disable-gpu',
      '--disable-blink-features=AutomationControlled'
    ]
  });

  const page = await browser.newPage();

  // 代理认证
  await page.authenticate({
    username: PROXY_USER,
    password: PROXY_PASS
  });

  // 设置视口和用户代理
  await page.setViewport({ width: 1920, height: 1080 });
  await page.setUserAgent(
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ' +
    'AppleWebKit/537.36 (KHTML, like Gecko) ' +
    'Chrome/120.0.0.0 Safari/537.36'
  );

  // 检查 IP
  await page.goto('https://httpbin.org/ip');
  const content = await page.content();
  console.log('当前 IP:', content);

  await browser.close();
})();

// npm install puppeteer-extra puppeteer-extra-plugin-stealth
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

// 添加 stealth 插件
puppeteer.use(StealthPlugin());

(async () => {
  const PROXY = 'proxy.proxycove.com:12345';

  const browser = await puppeteer.launch({
    headless: true,
    args: [
      `--proxy-server=${PROXY}`,
      '--no-sandbox',
      '--disable-setuid-sandbox'
    ]
  });

  const page = await browser.newPage();

  // 认证
  await page.authenticate({
    username: 'your_username',
    password: 'your_password'
  });

  // 模拟真实行为
  await page.setViewport({
    width: 1920 + Math.floor(Math.random() * 100),
    height: 1080 + Math.floor(Math.random() * 100)
  });

  // 跳转到网站
  await page.goto('https://www.google.com', {
    waitUntil: 'networkidle2'
  });

  // 模拟鼠标移动（对绕过机器人检测很重要）
  await page.mouse.move(100, 100);
  await page.mouse.move(200, 200);

  // 抓取
  const title = await page.title();
  console.log('页面标题:', title);

  await browser.close();
})();

性能提示： 每个 Puppeteer 实例消耗约 100-200MB RAM。当扩展到 10 多个浏览器实例时，请考虑使用浏览器池并限制并发实例的数量。

const { chromium } = require('playwright');

(async () => {
  // 代理配置
  const browser = await chromium.launch({
    proxy: {
      server: 'http://proxy.proxycove.com:12345',
      username: 'your_username',
      password: 'your_password'
    },
    headless: true
  });

  const context = await browser.newContext({
    viewport: { width: 1920, height: 1080 },
    userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
  });

  const page = await context.newPage();

  // Playwright 默认比 Puppeteer 更难被检测
  await page.goto('https://bot.sannysoft.com/');

  // 截图以供检查
  await page.screenshot({ path: 'test.png' });

  await browser.close();
})();

2025年推荐： Playwright 在功能和性能上正在超越 Puppeteer。它原生支持 Firefox 和 WebKit，并具有更好的元素等待 API 和网络错误自动重试功能。

轮换策略

• 数据抓取： 每 5-20 个请求更换一次 IP
• 账户操作： 粘性会话最长 120 分钟
• API 客户端： 一个会话使用一个 IP
• Discord 机器人： 每个 IP 保持 24-48 小时

逼真机器人清单

• ✅ 随机延迟： 动作之间间隔 0.5-3 秒
• ✅ 自然模式： 模拟滚动和鼠标移动
• ✅ 变化的用户代理： 使用最新的 User-Agents 池
• ✅ 模拟错误： 有时出现输入错误或取消操作
• ✅ 活动模式： 白天活动，有“睡眠”休息时间
• ✅ 输入速度： 40-80 WPM 带有变化
• ✅ 休息时间： 随机暂停 5-15 分钟
• ✅ 地理一致性： IP 应与账户时区匹配

监控内容

• 跟踪速率限制头信息
• 记录所有 429, 403, 503 错误
• 监控代理的成功率（请求成功百分比）
• 代理池中工作代理的百分比 (>90%)
• 服务器资源使用情况：CPU、RAM、网络
• 成本跟踪：代理支出 vs 预算

建议： 为关键指标设置 Telegram/Slack 警报。快速响应问题可以避免大规模封号和停机。

• 速率限制： 指数退避
• 网络错误： 自动重试（最多3次）
• 故障代理： 断路器 (Circuit breaker) 模式
• 优雅降级： 切换到备用代理
• 死信队列 (Dead letter queue)： 存放失败的请求

可扩展系统的组件

建议：从小规模开始，验证单位经济效益（每个机器人/账户的投资回报率），然后再进行扩展。70%的自动化项目因低估复杂性而无法盈利。

节省成本策略

• 粘性会话： 每次请求都轮换 IP，不如会话保持 IP 120 分钟更经济
• 精确目标定位： 不要为抓取俄罗斯网站购买美国 IP
• 流量估算： 监控实际流量（许多人支付的费用是实际需求的 2-3 倍）
• 分层方法： 70% 的任务使用数据中心代理，仅在必要时使用住宅代理
• 批量购买： ProxyCove 对大批量购买提供折扣

任务： 每日监控 50,000+ 商品的竞争对手价格

解决方案：

• Puppeteer + ProxyCove 住宅代理
• 每 10 个请求轮换一次 IP
• 分布式架构：10 个工作进程
• 速率限制：每个工作进程每秒 5 个请求

结果： 3小时内完成全部抓取，0次封锁，代理成本约$200/月

任务： 推广 50 个品牌 Instagram 账户

解决方案：

• GoLogin 反指纹浏览器
• 50x ProxyCove 移动代理（每个账户一个专用IP）
• 14天预热：每天 10→200 次操作
• 模拟人类行为：随机延迟、输入错误

结果： 6个月内无封号，粉丝增长+45,000，代理成本约$570/月

任务： 每日向 100,000+ 用户发送通知

解决方案：

• Python-telegram-bot 配合队列（Celery）
• 5x ProxyCove 数据中心代理用于负载分发
• 速率限制：全局每秒 30 条消息
• 收到 429 错误时使用指数退避

结果： 55分钟内发送 100,000 条消息，送达率 99.8%，代理成本约$30/月

任务： 在 200 个 Discord 服务器上进行自动版主管理

解决方案：

• Discord.js + Node.js 集群
• 200x ProxyCove IPv6 住宅代理（每个机器人一个IP）
• 使用 HTTPS 代理以确保 WebSocket 兼容性
• 健康检查和断开连接自动重启

结果： 99.9% 稳定运行时间，处理 1M+ 事件/天，代理成本约$540/月

监控指标

• 成功率： 成功请求百分比（应 >95%）
• 响应时间： 代理平均延迟（<2 秒）
• 错误率： 429, 403, 503 错误的频率
• 代理健康度： 代理池中正常工作的代理百分比 (>90%)
• 资源使用： 服务器上的 CPU、RAM、网络
• 成本跟踪： 代理支出 vs 预算

建议： 为关键指标设置 Telegram/Slack 警报。快速响应问题可以避免大规模封号和停机。

1. 代理是必需品，而非选项。 没有高质量的代理，您的机器人将在几小时内被封禁。
2. 住宅IP至关重要。 数据中心代理在2025年很容易被检测到。
3. 单一代理类型不适用所有场景。 采用分层方法：关键操作使用移动代理，主要工作使用住宅代理，数据中心代理用于API。
4. 隐身技术是强制性的。 没有 stealth 插件的 Selenium/Puppeteer 会立即被检测到。
5. 预热能防止封号。 新账户和新IP需要逐步增加活动量。
6. 监控即生存。 没有实时监控，您直到为时已晚才知晓问题。
7. 规模化需要架构。 任务队列、代理池、分布式速率限制不再是奢侈品，而是最低要求。
8. 投资回报率比规模更重要。 10个盈利的机器人胜过100个亏损的机器人。

初学者（1-10个机器人）

• ✅ 从ProxyCove 数据中心代理（$1.5/GB）开始
• ✅ 使用现成的库（python-telegram-bot, discord.js）
• ✅ 添加 selenium-stealth 或 puppeteer-extra-stealth
• ✅ 小规模测试 2-4 周
• ✅ 监控成功率和错误

中级用户（10-50个机器人）

• ✅ 升级到ProxyCove 住宅代理（$2.7/GB）
• ✅ 引入任务队列（Celery, Bull）来分配负载
• ✅ 设置带健康检查的代理池管理器
• ✅ 使用 Prometheus + Grafana 进行监控
• ✅ 对社交媒体账户使用反指纹浏览器

高级用户（50+ 机器人）

• ✅ 混合代理：ProxyCove 移动代理（$3.8/GB）用于关键操作 + 住宅代理用于主要工作
• ✅ 使用 Kubernetes 集群管理数百个工作进程
• ✅ 基于 Redis 的分布式速率限制器
• ✅ 使用 ELK Stack 进行集中式日志记录
• ✅ 采用断路器模式以实现故障恢复能力
• ✅ 对自动化策略进行 A/B 测试