डिस्कॉर्ड बॉट्स के लिए प्रॉक्सी: बिना बैन और रेट लिमिट्स के ऑटोमेशन सेटअप कैसे करें

मॉडरेशन और सर्वर प्रबंधन (1-3 बॉट): स्थिर IP के साथ रिहायशी प्रॉक्सी। एक बॉट — एक IP, बिना रोटेशन के। यह एक स्थिर कनेक्शन प्रोफ़ाइल बनाता है, जिसे Discord एक सामान्य प्रशासनिक उपयोगकर्ता के रूप में मानता है।

सामूहिक प्रचार और आमंत्रण (10+ बॉट): हर 5-10 मिनट में रोटेशन के साथ रिहायशी प्रॉक्सी। लोड को वितरित करें: एक IP से प्रति घंटे 20 क्रियाओं से अधिक नहीं। 10 बॉट्स के लिए 50+ IP पतों का पूल का उपयोग करें।

सदस्यों और सर्वरों का पार्सिंग: तेज रोटेशन (हर 1-3 मिनट) के साथ रिहायशी प्रॉक्सी या मोबाइल प्रॉक्सी। पार्सिंग सबसे जोखिम भरी गतिविधियों में से एक है, Discord आसानी से स्कैनिंग पैटर्न को पहचानता है। अनुरोधों के बीच यादृच्छिक देरी का उपयोग करें (30-120 सेकंड)।

परीक्षण और विकास: कार्यक्षमता को डिबग करने के लिए डेटा सेंटर प्रॉक्सी पर्याप्त हैं। लेकिन उत्पादन में जाने से पहले, रिहायशी प्रॉक्सी पर स्विच करना सुनिश्चित करें - Discord का व्यवहार विभिन्न प्रकार के IP के लिए बहुत भिन्न हो सकता है।

# Python (discord.py) में दर सीमा पर प्रॉक्सी के साथ रोटेशन का उदाहरण

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):
        # काम नहीं करने वाली प्रॉक्सी को छोड़ें
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            self.failed_proxies.clear()  # पूर्ण चक्र के बाद रीसेट
            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)

# प्रारंभिक सेटअप
proxy_rotator = ProxyRotator([
    'http://user1:pass1@192.168.1.1:8080',
    'http://user2:pass2@192.168.1.2:8080',
    # ... स्थिरता के लिए 10-20 प्रॉक्सी जोड़ें
])

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

async def send_with_retry(channel, message, max_retries=3):
    """दर सीमाओं के साथ स्वचालित रूप से संदेश भेजना"""
    for attempt in range(max_retries):
        try:
            # प्रत्येक प्रयास में नया प्रॉक्सी प्राप्त करें
            proxy = proxy_rotator.get_next_proxy()
            
            # Discord.py अंदर aiohttp का उपयोग करता है, प्रॉक्सी सेट करें
            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:  # दर सीमा
                retry_after = e.retry_after if hasattr(e, 'retry_after') else 5
                print(f"दर सीमा! {retry_after} सेकंड प्रतीक्षा कर रहे हैं, प्रॉक्सी बदल रहे हैं...")
                
                # प्रॉक्सी को अस्थायी रूप से अनुपलब्ध के रूप में चिह्नित करें
                proxy_rotator.mark_failed(proxy)
                
                # देरी में यादृच्छिकता जोड़ें
                await asyncio.sleep(retry_after + random.uniform(1, 3))
            else:
                print(f"संदेश भेजने में त्रुटि: {e}")
                await asyncio.sleep(2)
    
    return False

@bot.event
async def on_ready():
    print(f'बॉट चालू है: {bot.user}')

# उपयोग का उदाहरण
@bot.command()
async def mass_send(ctx):
    channels = ctx.guild.text_channels[:5]  # पहले 5 चैनल
    
    for channel in channels:
        success = await send_with_retry(channel, "परीक्षण संदेश")
        if success:
            print(f"{channel.name} में भेजा गया")
        
        # चैनलों के बीच यादृच्छिक देरी
        await asyncio.sleep(random.uniform(3, 7))
    

# Python (discord.py) - स्थिर प्रॉक्सी
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)

# प्रॉक्सी इस बॉट के सभी अनुरोधों के लिए उपयोग की जाएगी
bot.run('YOUR_BOT_TOKEN')
    

# JavaScript (discord.js) - समय के अनुसार रोटेशन
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() }
});

// हर 5 मिनट में रोटेशन
setInterval(() => {
    console.log('प्रॉक्सी बदल रहा है...');
    client.rest.setAgent(getProxyAgent());
}, 5 * 60 * 1000);

client.login('YOUR_BOT_TOKEN');
    

# Python - ब्लैकलिस्ट के साथ अनुकूलन रोटेशन
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()
        
        # ब्लैकलिस्ट में प्रॉक्सी को फ़िल्टर करें
        available = [
            p for p in self.proxies 
            if p not in self.blacklist_until or self.blacklist_until[p] < now
        ]
        
        if not available:
            # यदि सभी ब्लैकलिस्ट में हैं, तो रीसेट करें और प्रतीक्षा करें
            print("सभी प्रॉक्सी ब्लैकलिस्ट में हैं, 60 सेकंड प्रतीक्षा कर रहे हैं...")
            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
        
        # कई त्रुटियों पर अस्थायी ब्लॉक
        if self.error_count[proxy] >= 3:
            blacklist_duration = 300  # 5 मिनट
            self.blacklist_until[proxy] = time.time() + blacklist_duration
            print(f"प्रॉक्सी {proxy} ब्लैकलिस्ट में {blacklist_duration} सेकंड के लिए")
            self.error_count[proxy] = 0  # काउंटर रीसेट
    
    def report_success(self, proxy):
        # सफल अनुरोध - त्रुटियों के काउंटर को रीसेट करें
        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 SOCKS5 प्रॉक्सी के लिए आवश्यक है, HTTP/HTTPS के लिए यह अनिवार्य नहीं है
    

import discord
from discord.ext import commands

# प्रॉक्सी का प्रारूप: protocol://username:password@ip:port
PROXY = 'http://user:pass@192.168.1.100:8080'

intents = discord.Intents.default()
intents.message_content = True  # संदेश पढ़ने के लिए

bot = commands.Bot(
    command_prefix='!',
    intents=intents,
    proxy=PROXY  # सभी HTTP अनुरोधों के लिए प्रॉक्सी
)

@bot.event
async def on_ready():
    print(f'बॉट {bot.user} प्रॉक्सी के माध्यम से कनेक्ट किया गया!')

@bot.command()
async def ping(ctx):
    await ctx.send(f'पॉन्ग! देरी: {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)  # हर 5 मिनट में रोटेशन
    async def proxy_rotation(self):
        old_proxy = self.current_proxy
        self.current_proxy = random.choice([p for p in PROXIES if p != old_proxy])
        
        # नए प्रॉक्सी के साथ HTTP सत्र को फिर से बनाएं
        await self.http.close()
        connector = aiohttp.TCPConnector(limit=0)
        self.http.connector = connector
        self.http.__session = aiohttp.ClientSession(connector=connector)
        
        print(f'प्रॉक्सी बदल गया: {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
# 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 }  // REST API अनुरोधों के लिए प्रॉक्सी
});

client.on('ready', () => {
    console.log(`बॉट ${client.user.tag} प्रॉक्सी के माध्यम से कनेक्ट किया गया!`);
});

client.on('messageCreate', async (message) => {
    if (message.content === '!ping') {
        await message.reply(`पॉन्ग! 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() }
});

// हर 10 मिनट में रोटेशन
setInterval(() => {
    const newAgent = getNextProxy();
    client.rest.setAgent(newAgent);
    console.log('प्रॉक्सी बदल गया');
}, 10 * 60 * 1000);

client.on('ready', () => {
    console.log(`बॉट ${client.user.tag} चालू है`);
});

client.login('YOUR_BOT_TOKEN');
    

# Python - कस्टम User-Agent
import discord

class CustomBot(discord.Client):
    async def request(self, *args, **kwargs):
        # 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 - मेट्रिक्स के साथ उन्नत लॉगिंग
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
        })
        
        # लॉगर सेटअप
        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'प्रॉक्सी {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} बैन (403)');
        else:
            self.metrics['errors_other'] += 1
            self.logger.error(f'त्रुटि {status_code} प्रॉक्सी {proxy} पर');
    
    def log_proxy_switch(self, old_proxy, new_proxy):
        self.metrics['proxy_switches'] += 1
        self.logger.info(f'प्रॉक्सी बदलना: {old_proxy} -> {new_proxy}');
    
    def get_report(self):
        total = self.metrics['requests_total']
        if total == 0:
            return "कोई डेटा नहीं";
        
        success_rate = (self.metrics['requests_success'] / total) * 100
        avg_latency = sum(self.metrics['avg_latency']) / len(self.metrics['avg_latency'])
        
        report = f"""
=== बॉट निगरानी रिपोर्ट ===
कुल अनुरोध: {total}
सफल: {self.metrics['requests_success']} ({success_rate:.1f}%)
त्रुटियाँ 429 (दर सीमा): {self.metrics['errors_429']}
त्रुटियाँ 403 (बैन): {self.metrics['errors_403']}
अन्य त्रुटियाँ: {self.metrics['errors_other']}
औसत देरी: {avg_latency:.0f}ms
प्रॉक्सी स्विच: {self.metrics['proxy_switches']}

=== प्रॉक्सी सांख्यिकी ===
"""
        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']} अनुरोध, {stats['errors']} त्रुटियाँ ({error_rate:.1f}%)\n"
        return report