Proxy cho bot Discord: cách thiết lập tự động hóa không bị cấm và giới hạn tần suất

Quản lý và điều hành máy chủ (1-3 bot): Proxy cư trú với IP cố định. Một bot — một IP, không có xoay vòng. Điều này tạo ra một hồ sơ kết nối ổn định mà Discord coi là người dùng quản trị viên bình thường.

Gửi thư mời hàng loạt và mời (10+ bot): Proxy cư trú với xoay vòng mỗi 5-10 phút. Phân phối tải: không quá 20 hành động trong một giờ từ một IP. Sử dụng nguồn từ 50+ địa chỉ IP cho 10 bot.

Phân tích người dùng và máy chủ: Proxy cư trú với xoay vòng nhanh (mỗi 1-3 phút) hoặc proxy di động. Phân tích là một trong những hoạt động rủi ro nhất, Discord dễ dàng tính toán các mẫu quét. Sử dụng độ trễ ngẫu nhiên giữa các yêu cầu (30-120 giây).

Kiểm tra và phát triển: Proxy trung tâm dữ liệu là đủ để gỡ lỗi chức năng. Nhưng trước khi đưa vào sản xuất, hãy chắc chắn chuyển sang proxy cư trú — hành vi của Discord có thể khác biệt lớn cho các loại IP khác nhau.

# Ví dụ bằng Python (discord.py) với xoay vòng proxy khi gặp giới hạn tần suất

import discord
from discord.ext import commands
import aiohttp
import asyncio
import random

class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list  # ['http://user:pass@ip:port', ...]
        self.current_index = 0
        self.failed_proxies = set()
    
    def get_next_proxy(self):
        # Bỏ qua các proxy không hoạt động
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            self.failed_proxies.clear()  # Đặt lại sau một vòng hoàn chỉnh
            available = self.proxies
        
        proxy = available[self.current_index % len(available)]
        self.current_index += 1
        return proxy
    
    def mark_failed(self, proxy):
        self.failed_proxies.add(proxy)

# Khởi tạo
proxy_rotator = ProxyRotator([
    'http://user1:pass1@192.168.1.1:8080',
    'http://user2:pass2@192.168.1.2:8080',
    # ... thêm 10-20 proxy để hoạt động ổn định
])

intents = discord.Intents.default()
bot = commands.Bot(command_prefix='!', intents=intents)

async def send_with_retry(channel, message, max_retries=3):
    """Gửi tin nhắn với xử lý tự động giới hạn tần suất"""
    for attempt in range(max_retries):
        try:
            # Lấy proxy mới cho mỗi lần thử
            proxy = proxy_rotator.get_next_proxy()
            
            # Discord.py sử dụng aiohttp bên trong, cấu hình proxy
            connector = aiohttp.TCPConnector()
            async with aiohttp.ClientSession(connector=connector) as session:
                bot.http.connector = connector
                bot.http.proxy = proxy
                
                await channel.send(message)
                return True
                
        except discord.HTTPException as e:
            if e.status == 429:  # Giới hạn tần suất
                retry_after = e.retry_after if hasattr(e, 'retry_after') else 5
                print(f"Giới hạn tần suất! Chờ {retry_after} giây, đổi proxy...")
                
                # Đánh dấu proxy là tạm thời không khả dụng
                proxy_rotator.mark_failed(proxy)
                
                # Thêm sự ngẫu nhiên vào độ trễ
                await asyncio.sleep(retry_after + random.uniform(1, 3))
            else:
                print(f"Lỗi gửi: {e}")
                await asyncio.sleep(2)
    
    return False

@bot.event
async def on_ready():
    print(f'Bot đã khởi động: {bot.user}')

# Ví dụ sử dụng
@bot.command()
async def mass_send(ctx):
    channels = ctx.guild.text_channels[:5]  # 5 kênh đầu tiên
    
    for channel in channels:
        success = await send_with_retry(channel, "Tin nhắn thử nghiệm")
        if success:
            print(f"Đã gửi đến {channel.name}")
        
        # Độ trễ ngẫu nhiên giữa các kênh
        await asyncio.sleep(random.uniform(3, 7))
    

# Python (discord.py) - proxy cố định
import discord
from discord.ext import commands

PROXY = 'http://username:password@192.168.1.100:8080'

intents = discord.Intents.default()
bot = commands.Bot(command_prefix='!', intents=intents, proxy=PROXY)

# Proxy sẽ được sử dụng cho tất cả các yêu cầu của bot này
bot.run('YOUR_BOT_TOKEN')
    

# JavaScript (discord.js) - xoay vòng theo thời gian
const { Client, GatewayIntentBits } = require('discord.js');
const HttpsProxyAgent = require('https-proxy-agent');

const proxies = [
    'http://user1:pass1@ip1:port',
    'http://user2:pass2@ip2:port',
    'http://user3:pass3@ip3:port',
];

let currentProxyIndex = 0;

function getProxyAgent() {
    const proxy = proxies[currentProxyIndex];
    currentProxyIndex = (currentProxyIndex + 1) % proxies.length;
    return new HttpsProxyAgent(proxy);
}

const client = new Client({
    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
    rest: { agent: getProxyAgent() }
});

// Xoay vòng mỗi 5 phút
setInterval(() => {
    console.log('Đổi proxy...');
    client.rest.setAgent(getProxyAgent());
}, 5 * 60 * 1000);

client.login('YOUR_BOT_TOKEN');
    

# Python - xoay vòng thích ứng với danh sách đen
import time
from collections import defaultdict

class AdaptiveProxyRotator:
    def __init__(self, proxies):
        self.proxies = proxies
        self.current = 0
        self.error_count = defaultdict(int)
        self.blacklist_until = {}  # {proxy: timestamp}
    
    def get_proxy(self):
        now = time.time()
        
        # Lọc proxy trong danh sách đen
        available = [
            p for p in self.proxies 
            if p not in self.blacklist_until or self.blacklist_until[p] < now
        ]
        
        if not available:
            # Nếu tất cả đều trong danh sách đen, đặt lại và chờ
            print("Tất cả proxy trong danh sách đen, chờ 60 giây...")
            time.sleep(60)
            self.blacklist_until.clear()
            available = self.proxies
        
        proxy = available[self.current % len(available)]
        self.current += 1
        return proxy
    
    def report_error(self, proxy, error_type):
        self.error_count[proxy] += 1
        
        # Cấm tạm thời khi gặp nhiều lỗi
        if self.error_count[proxy] >= 3:
            blacklist_duration = 300  # 5 phút
            self.blacklist_until[proxy] = time.time() + blacklist_duration
            print(f"Proxy {proxy} vào danh sách đen trong {blacklist_duration} giây")
            self.error_count[proxy] = 0  # Đặt lại bộ đếm
    
    def report_success(self, proxy):
        # Yêu cầu thành công - đặt lại bộ đếm lỗi
        if proxy in self.error_count:
            self.error_count[proxy] = max(0, self.error_count[proxy] - 1)
    

pip install discord.py aiohttp aiohttp-socks
# aiohttp-socks cần thiết cho proxy SOCKS5, không bắt buộc cho HTTP/HTTPS
    

import discord
from discord.ext import commands

# Định dạng proxy: protocol://username:password@ip:port
PROXY = 'http://user:pass@192.168.1.100:8080'

intents = discord.Intents.default()
intents.message_content = True  # Để đọc tin nhắn

bot = commands.Bot(
    command_prefix='!',
    intents=intents,
    proxy=PROXY  # Proxy cho tất cả các yêu cầu HTTP
)

@bot.event
async def on_ready():
    print(f'Bot {bot.user} đã kết nối qua proxy!')

@bot.command()
async def ping(ctx):
    await ctx.send(f'Pong! Độ trễ: {round(bot.latency * 1000)}ms')

bot.run('YOUR_BOT_TOKEN')
    

import discord
from discord.ext import commands, tasks
import aiohttp
import random

PROXIES = [
    'http://user1:pass1@ip1:port',
    'http://user2:pass2@ip2:port',
    'http://user3:pass3@ip3:port',
]

class ProxyBot(commands.Bot):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.current_proxy = random.choice(PROXIES)
        self.proxy_rotation.start()
    
    @tasks.loop(minutes=5)  # Xoay vòng mỗi 5 phút
    async def proxy_rotation(self):
        old_proxy = self.current_proxy
        self.current_proxy = random.choice([p for p in PROXIES if p != old_proxy])
        
        # Tạo lại phiên HTTP với proxy mới
        await self.http.close()
        connector = aiohttp.TCPConnector(limit=0)
        self.http.connector = connector
        self.http.__session = aiohttp.ClientSession(connector=connector)
        
        print(f'Proxy đã thay đổi: {old_proxy} -> {self.current_proxy}')
    
    async def close(self):
        self.proxy_rotation.cancel()
        await super().close()

intents = discord.Intents.default()
bot = ProxyBot(command_prefix='!', intents=intents)

bot.run('YOUR_BOT_TOKEN')
    

npm install discord.js https-proxy-agent
# Đối với SOCKS5: npm install socks-proxy-agent
    

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

const PROXY = 'http://user:pass@192.168.1.100:8080';
const agent = new HttpsProxyAgent(PROXY);

const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent
    ],
    rest: { agent: agent }  // Proxy cho các yêu cầu REST API
});

client.on('ready', () => {
    console.log(`Bot ${client.user.tag} đã kết nối qua proxy!`);
});

client.on('messageCreate', async (message) => {
    if (message.content === '!ping') {
        await message.reply(`Pong! Độ trễ WebSocket: ${client.ws.ping}ms`);
    }
});

client.login('YOUR_BOT_TOKEN');
    

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

const PROXIES = [
    'http://user1:pass1@ip1:port',
    'http://user2:pass2@ip2:port',
    'http://user3:pass3@ip3:port',
];

let currentProxyIndex = 0;

function getNextProxy() {
    const proxy = PROXIES[currentProxyIndex];
    currentProxyIndex = (currentProxyIndex + 1) % PROXIES.length;
    return new HttpsProxyAgent(proxy);
}

const client = new Client({
    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
    rest: { agent: getNextProxy() }
});

// Xoay vòng mỗi 10 phút
setInterval(() => {
    const newAgent = getNextProxy();
    client.rest.setAgent(newAgent);
    console.log('Proxy đã thay đổi');
}, 10 * 60 * 1000);

client.on('ready', () => {
    console.log(`Bot ${client.user.tag} đã khởi động`);
});

client.login('YOUR_BOT_TOKEN');
    

# Python - User-Agent tùy chỉnh
import discord

class CustomBot(discord.Client):
    async def request(self, *args, **kwargs):
        # Ghi đè User-Agent
        if 'headers' not in kwargs:
            kwargs['headers'] = {}
        kwargs['headers']['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Discord/1.0.9015'
        return await super().request(*args, **kwargs)
    

# Python - ghi log nâng cao với các chỉ số
import logging
import time
from collections import defaultdict
import json

class BotMonitor:
    def __init__(self):
        self.metrics = {
            'requests_total': 0,
            'requests_success': 0,
            'errors_429': 0,
            'errors_403': 0,
            'errors_other': 0,
            'proxy_switches': 0,
            'avg_latency': []
        }
        self.proxy_stats = defaultdict(lambda: {
            'requests': 0,
            'errors': 0,
            'last_error': None
        })
        
        # Cấu hình logger
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('bot_monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger('BotMonitor')
    
    def log_request(self, proxy, status_code, latency):
        self.metrics['requests_total'] += 1
        self.metrics['avg_latency'].append(latency)
        self.proxy_stats[proxy]['requests'] += 1
        
        if 200 <= status_code < 300:
            self.metrics['requests_success'] += 1
        elif status_code == 429:
            self.metrics['errors_429'] += 1
            self.proxy_stats[proxy]['errors'] += 1
            self.logger.warning(f'Giới hạn tần suất trên proxy {proxy}')
        elif status_code == 403:
            self.metrics['errors_403'] += 1
            self.proxy_stats[proxy]['errors'] += 1
            self.proxy_stats[proxy]['last_error'] = time.time()
            self.logger.error(f'Proxy {proxy} bị cấm (403)')
        else:
            self.metrics['errors_other'] += 1
            self.logger.error(f'Lỗi {status_code} trên proxy {proxy}')
    
    def log_proxy_switch(self, old_proxy, new_proxy):
        self.metrics['proxy_switches'] += 1
        self.logger.info(f'Chuyển proxy: {old_proxy} -> {new_proxy}')
    
    def get_report(self):
        total = self.metrics['requests_total']
        if total == 0:
            return "Không có dữ liệu"
        
        success_rate = (self.metrics['requests_success'] / total) * 100
        avg_latency = sum(self.metrics['avg_latency']) / len(self.metrics['avg_latency'])
        
        report = f"""
=== BÁO CÁO GIÁM SÁT BOT ===
Tổng số yêu cầu: {total}
Số yêu cầu thành công: {self.metrics['requests_success']} ({success_rate:.1f}%)
Số lỗi 429 (giới hạn tần suất): {self.metrics['errors_429']}
Số lỗi 403 (cấm): {self.metrics['errors_403']}
Số lỗi khác: {self.metrics['errors_other']}
Độ trễ trung bình: {avg_latency:.0f}ms
Số lần chuyển proxy: {self.metrics['proxy_switches']}

=== THỐNG KÊ THEO PROXY ===
"""
        for proxy, stats in self.proxy_stats.items():
            error_rate = (stats['errors'] / stats['requests'] * 100) if stats['requests'] > 0 else 0
            report += f"{proxy}: {stats['requests']} yêu cầu, {stats['errors']} lỗi ({error_rate:.1f}%)\n"
        return report