बड़े अनुरोधों पर ब्लॉकिंग से बचाव: तकनीकें और उपकरण

खाता और आईपी पते की ब्लॉकिंग - वेब स्क्रैपिंग, ऑटोमेशन और सोशल मीडिया पर बड़े ऑपरेशनों में मुख्य समस्या है। आधुनिक एंटी-बॉट सिस्टम दर्जनों पैरामीटर का विश्लेषण करते हैं: अनुरोधों की आवृत्ति से लेकर ब्राउज़र के फिंगरप्रिंट तक। इस मार्गदर्शिका में, हम स्वचालन का पता लगाने के विशिष्ट तंत्र और उनके बायपास के व्यावहारिक तरीकों की व्याख्या करेंगे।

स्वचालन का पता लगाने के तंत्र

आधुनिक सुरक्षा प्रणालियाँ बॉट्स की पहचान के लिए बहु-स्तरीय विश्लेषण का उपयोग करती हैं। इन तंत्रों को समझना सही बायपास रणनीति चुनने के लिए महत्वपूर्ण है।

विश्लेषण के मुख्य पैरामीटर

अनुरोधों की आवृत्ति (Request Rate): एक व्यक्ति शारीरिक रूप से प्रति मिनट 100 अनुरोध नहीं भेज सकता। सिस्टम न केवल कुल संख्या का विश्लेषण करते हैं, बल्कि समय में वितरण का भी - अनुरोधों के बीच समान अंतराल बॉट का संकेत देते हैं।

व्यवहार के पैटर्न: क्रियाओं की अनुक्रम, स्क्रॉलिंग की गहराई, माउस की गति, पृष्ठ पर समय। एक बॉट जो बिना किसी देरी के लिंक पर तुरंत जाता है, उसे आसानी से पहचाना जा सकता है।

तकनीकी फिंगरप्रिंट: यूजर-एजेंट, HTTP हेडर, हेडर का क्रम, TLS-फिंगरप्रिंट, कैनवास/वेबजीएल फिंगरप्रिंट। इन पैरामीटर में असंगतता एंटी-बॉट सिस्टम के लिए एक लाल झंडा है।

दर सीमा और अनुरोधों की आवृत्ति का नियंत्रण

अनुरोधों की गति का नियंत्रण - ब्लॉकिंग से बचने की पहली पंक्ति है। प्रॉक्सी रोटेशन के साथ भी, अत्यधिक आक्रामक स्क्रैपिंग बैन का कारण बन सकती है।

गतिशील देरी

निश्चित अंतराल (जैसे, अनुरोधों के बीच ठीक 2 सेकंड) आसानी से पहचाने जाते हैं। सामान्य वितरण के साथ यादृच्छिक देरी का उपयोग करें:

import time
import random
import numpy as np

def human_delay(min_delay=1.5, max_delay=4.0, mean=2.5, std=0.8):
    """
    मानव व्यवहार की नकल करने के लिए सामान्य वितरण के साथ देरी उत्पन्न करना
    """
    delay = np.random.normal(mean, std)
    # सीमा निर्धारित करना
    delay = max(min_delay, min(delay, max_delay))
    
    # यथार्थता के लिए सूक्ष्म देरी जोड़ना
    delay += random.uniform(0, 0.3)
    
    time.sleep(delay)

# उपयोग
for url in urls:
    response = session.get(url)
    human_delay(min_delay=2, max_delay=5, mean=3, std=1)

अनुकूलन दर सीमा

एक अधिक उन्नत दृष्टिकोण - सर्वर के उत्तरों के आधार पर गति को अनुकूलित करना। यदि आप 429 (बहुत अधिक अनुरोध) या 503 कोड प्राप्त करते हैं, तो स्वचालित रूप से गति कम करें:

class AdaptiveRateLimiter:
    def __init__(self, initial_delay=2.0):
        self.current_delay = initial_delay
        self.min_delay = 1.0
        self.max_delay = 30.0
        self.error_count = 0
        
    def wait(self):
        time.sleep(self.current_delay + random.uniform(0, 0.5))
        
    def on_success(self):
        # सफल अनुरोधों पर धीरे-धीरे गति बढ़ाना
        self.current_delay = max(
            self.min_delay, 
            self.current_delay * 0.95
        )
        self.error_count = 0
        
    def on_rate_limit(self):
        # ब्लॉकिंग पर तेजी से धीमा करना
        self.error_count += 1
        self.current_delay = min(
            self.max_delay,
            self.current_delay * (1.5 + self.error_count * 0.5)
        )
        print(f"दर सीमा हिट। नई देरी: {self.current_delay:.2f}s")

# उपयोग
limiter = AdaptiveRateLimiter(initial_delay=2.0)

for url in urls:
    limiter.wait()
    response = session.get(url)
    
    if response.status_code == 429:
        limiter.on_rate_limit()
        time.sleep(60)  # पुनः प्रयास से पहले विराम
    elif response.status_code == 200:
        limiter.on_success()
    else:
        # अन्य त्रुटियों का प्रबंधन
        pass

प्रॉक्सी रोटेशन और आईपी पते का प्रबंधन

बड़े अनुरोधों के लिए एक ही आईपी पते का उपयोग करना ब्लॉकिंग की गारंटी देता है। प्रॉक्सी रोटेशन लोड को वितरित करता है और पहचान के जोखिम को कम करता है।

रोटेशन रणनीतियाँ

1. अनुरोधों के अनुसार रोटेशन: प्रत्येक या हर N अनुरोध के बाद आईपी बदलना। खोज इंजनों के स्क्रैपिंग के लिए उपयुक्त, जहां प्रत्येक अनुरोध की गुमनामी महत्वपूर्ण है।

2. समय के अनुसार रोटेशन: हर 5-15 मिनट में आईपी बदलना। सामाजिक नेटवर्क के साथ काम करने के लिए प्रभावी, जहां सत्र की स्थिरता महत्वपूर्ण है।

3. स्टिकी सत्र: पूरी उपयोगकर्ता सत्र (प्राधिकरण, क्रियाओं का अनुक्रम) के लिए एक आईपी का उपयोग करना। CSRF सुरक्षा वाले साइटों के लिए महत्वपूर्ण है।

import requests
from itertools import cycle

class ProxyRotator:
    def __init__(self, proxy_list, rotation_type='request', rotation_interval=10):
        """
        rotation_type: 'request' (प्रत्येक अनुरोध) या 'time' (समय के अनुसार)
        rotation_interval: अनुरोधों की संख्या या सेकंड
        """
        self.proxies = cycle(proxy_list)
        self.current_proxy = next(self.proxies)
        self.rotation_type = rotation_type
        self.rotation_interval = rotation_interval
        self.request_count = 0
        self.last_rotation = time.time()
        
    def get_proxy(self):
        if self.rotation_type == 'request':
            self.request_count += 1
            if self.request_count >= self.rotation_interval:
                self.current_proxy = next(self.proxies)
                self.request_count = 0
                print(f"रोटेट किया गया: {self.current_proxy}")
                
        elif self.rotation_type == 'time':
            if time.time() - self.last_rotation >= self.rotation_interval:
                self.current_proxy = next(self.proxies)
                self.last_rotation = time.time()
                print(f"रोटेट किया गया: {self.current_proxy}")
                
        return {'http': self.current_proxy, 'https': self.current_proxy}

# उपयोग का उदाहरण
proxy_list = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    'http://user:pass@proxy3.example.com:8000',
]

rotator = ProxyRotator(proxy_list, rotation_type='request', rotation_interval=5)

for url in urls:
    proxies = rotator.get_proxy()
    response = requests.get(url, proxies=proxies, timeout=10)

प्रॉक्सी के प्रकार का चयन

सामाजिक नेटवर्क और गंभीर सुरक्षा वाले प्लेटफार्मों पर बड़े ऑपरेशनों के लिए रिहायशी प्रॉक्सी का उपयोग करें। ये सामान्य घरेलू कनेक्शन की तरह दिखते हैं और शायद ही कभी काले सूचियों में आते हैं। डेटा केंद्र कम सुरक्षित संसाधनों के लिए उपयुक्त हैं, जहां गति महत्वपूर्ण है।

ब्राउज़र फिंगरप्रिंटिंग और TLS फिंगरप्रिंट

आईपी रोटेशन के साथ भी, आपको ब्राउज़र और TLS कनेक्शन के तकनीकी फिंगरप्रिंट द्वारा पहचाना जा सकता है। ये पैरामीटर प्रत्येक ग्राहक के लिए अद्वितीय होते हैं और उनकी नकल करना कठिन होता है।

TLS फिंगरप्रिंटिंग

HTTPS कनेक्शन स्थापित करते समय, क्लाइंट समर्थित एन्क्रिप्शन और एक्सटेंशनों के सेट के साथ ClientHello भेजता है। यह संयोजन प्रत्येक पुस्तकालय के लिए अद्वितीय होता है। उदाहरण के लिए, Python requests OpenSSL का उपयोग करता है, जिसका फिंगरप्रिंट Chrome से आसानी से अलग किया जा सकता है।

समाधान: ब्राउज़र के फिंगरप्रिंट की नकल करने वाली पुस्तकालयों का उपयोग करें। Python के लिए यह curl_cffi, tls_client या पूर्ण ब्राउज़र अनुकरण के लिए playwright/puppeteer है।

# स्थापना: pip install curl-cffi
from curl_cffi import requests

# Chrome 110 की नकल करना
response = requests.get(
    'https://example.com',
    impersonate="chrome110",
    proxies={'https': 'http://proxy:port'}
)

# विकल्प: tls_client
import tls_client

session = tls_client.Session(
    client_identifier="chrome_108",
    random_tls_extension_order=True
)

response = session.get('https://example.com')

HTTP/2 फिंगरप्रिंटिंग

TLS के अलावा, एंटी-बॉट सिस्टम HTTP/2 के पैरामीटर का विश्लेषण करते हैं: हेडर का क्रम, SETTINGS फ्रेम की सेटिंग्स, स्ट्रीम प्राथमिकताएँ। मानक पुस्तकालय Chrome या Firefox के सटीक हेडर क्रम का पालन नहीं करते हैं।

# Chrome के लिए सही हेडर क्रम
headers = {
    ':method': 'GET',
    ':authority': 'example.com',
    ':scheme': 'https',
    ':path': '/',
    'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'upgrade-insecure-requests': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...',
    'accept': 'text/html,application/xhtml+xml...',
    'sec-fetch-site': 'none',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-user': '?1',
    'sec-fetch-dest': 'document',
    'accept-encoding': 'gzip, deflate, br',
    'accept-language': 'en-US,en;q=0.9',
}

कैनवास और वेबजीएल फिंगरप्रिंटिंग

ब्राउज़र GPU, ड्राइवर और OS के आधार पर ग्राफिक्स को अलग-अलग रेंडर करते हैं। साइटें इसे डिवाइस का अद्वितीय फिंगरप्रिंट बनाने के लिए उपयोग करती हैं। हेडलेस ब्राउज़रों (Selenium, Puppeteer) का उपयोग करते समय, स्वचालन के संकेतों को छिपाना महत्वपूर्ण है:

// Puppeteer: हेडलेस मोड को छिपाना
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

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

const page = await browser.newPage();

// navigator.webdriver को ओवरराइड करना
await page.evaluateOnNewDocument(() => {
    Object.defineProperty(navigator, 'webdriver', {
        get: () => false,
    });
});

हेडर, कुकीज़ और सत्र प्रबंधन

HTTP हेडरों और कुकीज़ के साथ सही काम करना वास्तविक उपयोगकर्ता की नकल के लिए महत्वपूर्ण है। इन पैरामीटर में त्रुटियाँ ब्लॉकिंग का एक सामान्य कारण हैं।

अनिवार्य हेडर

ब्राउज़र Chrome की नकल के लिए न्यूनतम हेडर सेट:

import requests

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
    'Accept-Language': 'en-US,en;q=0.9',
    'Accept-Encoding': 'gzip, deflate, br',
    'DNT': '1',
    'Connection': 'keep-alive',
    'Upgrade-Insecure-Requests': '1',
    'Sec-Fetch-Dest': 'document',
    'Sec-Fetch-Mode': 'navigate',
    'Sec-Fetch-Site': 'none',
    'Sec-Fetch-User': '?1',
    'Cache-Control': 'max-age=0',
}

session = requests.Session()
session.headers.update(headers)

कुकीज़ का प्रबंधन

कई साइटें पहले दौरे पर ट्रैकिंग कुकीज़ स्थापित करती हैं और बाद के अनुरोधों पर उनकी उपस्थिति की जांच करती हैं। कुकीज़ की अनुपस्थिति या उनका असंगत होना बॉट का संकेत है।

import requests
import pickle

class SessionManager:
    def __init__(self, session_file='session.pkl'):
        self.session_file = session_file
        self.session = requests.Session()
        self.load_session()
        
    def load_session(self):
        """सहेजी गई सत्र को लोड करना"""
        try:
            with open(self.session_file, 'rb') as f:
                cookies = pickle.load(f)
                self.session.cookies.update(cookies)
        except FileNotFoundError:
            pass
            
    def save_session(self):
        """पुनः उपयोग के लिए कुकीज़ को सहेजना"""
        with open(self.session_file, 'wb') as f:
            pickle.dump(self.session.cookies, f)
            
    def request(self, url, **kwargs):
        response = self.session.get(url, **kwargs)
        self.save_session()
        return response

# उपयोग
manager = SessionManager('instagram_session.pkl')
response = manager.request('https://www.instagram.com/explore/')

रेफरर और मूल

Referer और Origin हेडर दिखाते हैं कि उपयोगकर्ता कहाँ से आया। इनकी अनुपस्थिति या गलत मान लाल झंडा है।

# सही अनुक्रम: मुख्य → श्रेणी → उत्पाद
session = requests.Session()

# चरण 1: मुख्य पृष्ठ पर जाना
response = session.get('https://example.com/')

# चरण 2: श्रेणी में जाना
response = session.get(
    'https://example.com/category/electronics',
    headers={'Referer': 'https://example.com/'}
)

# चरण 3: उत्पाद देखना
response = session.get(
    'https://example.com/product/12345',
    headers={'Referer': 'https://example.com/category/electronics'}
)

मानव व्यवहार की नकल

तकनीकी पैरामीटर केवल आधा काम हैं। आधुनिक एंटी-बॉट सिस्टम व्यवहार पैटर्न का विश्लेषण करते हैं: उपयोगकर्ता पृष्ठ के साथ कैसे इंटरैक्ट करता है, वह कितना समय बिताता है, माउस कैसे चलता है।

स्क्रॉलिंग और माउस की गति

Selenium या Puppeteer का उपयोग करते समय, यादृच्छिक माउस गति और पृष्ठ स्क्रॉलिंग जोड़ें:

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
import random
import time

def human_like_mouse_move(driver):
    """पृष्ठ पर यादृच्छिक माउस गति"""
    action = ActionChains(driver)
    
    for _ in range(random.randint(3, 7)):
        x = random.randint(0, 1000)
        y = random.randint(0, 800)
        action.move_by_offset(x, y)
        action.pause(random.uniform(0.1, 0.3))
    
    action.perform()

def human_like_scroll(driver):
    """स्वाभाविक स्क्रॉलिंग की नकल करना"""
    total_height = driver.execute_script("return document.body.scrollHeight")
    current_position = 0
    
    while current_position < total_height:
        # यादृच्छिक स्क्रॉलिंग कदम
        scroll_step = random.randint(100, 400)
        current_position += scroll_step
        
        driver.execute_script(f"window.scrollTo(0, {current_position});")
        
        # विविधता के साथ विराम
        time.sleep(random.uniform(0.5, 1.5))
        
        # कभी-कभी थोड़ा पीछे स्क्रॉल करें (जैसे लोग करते हैं)
        if random.random() < 0.2:
            back_scroll = random.randint(50, 150)
            current_position -= back_scroll
            driver.execute_script(f"window.scrollTo(0, {current_position});")
            time.sleep(random.uniform(0.3, 0.8))

# उपयोग
driver = webdriver.Chrome()
driver.get('https://example.com')

human_like_mouse_move(driver)
time.sleep(random.uniform(2, 4))
human_like_scroll(driver)

पृष्ठ पर समय

वास्तविक उपयोगकर्ता पृष्ठ पर समय बिताते हैं: सामग्री पढ़ते हैं, छवियों को देखते हैं। एक बॉट जो तुरंत लिंक पर जाता है, उसे आसानी से पहचाना जा सकता है।

def realistic_page_view(driver, url, min_time=5, max_time=15):
    """
    सक्रियता के साथ यथार्थवादी पृष्ठ दृश्य
    """
    driver.get(url)
    
    # प्रारंभिक देरी (लोडिंग और "पढ़ाई")
    time.sleep(random.uniform(2, 4))
    
    # स्क्रॉलिंग
    human_like_scroll(driver)
    
    # अतिरिक्त सक्रियता
    total_time = random.uniform(min_time, max_time)
    elapsed = 0
    
    while elapsed < total_time:
        action_choice = random.choice(['scroll', 'mouse_move', 'pause'])
        
        if action_choice == 'scroll':
            # ऊपर/नीचे थोड़ा स्क्रॉल
            scroll_amount = random.randint(-200, 300)
            driver.execute_script(f"window.scrollBy(0, {scroll_amount});")
            pause = random.uniform(1, 3)
            
        elif action_choice == 'mouse_move':
            human_like_mouse_move(driver)
            pause = random.uniform(0.5, 2)
            
        else:  # pause
            pause = random.uniform(2, 5)
        
        time.sleep(pause)
        elapsed += pause

नेविगेशन पैटर्न

संदिग्ध पैटर्न से बचें: गहरे पृष्ठों पर सीधे जाना, मुख्य पृष्ठ की अनदेखी करना, बिना किसी अंतराल के सभी तत्वों का अनुक्रमिक रूप से दौरा करना।

क्लाउडफ्लेयर, डेटा डोम और अन्य सुरक्षा को बायपास करना

विशेष एंटी-बॉट सिस्टम एक समग्र दृष्टिकोण की आवश्यकता होती है। वे JavaScript चैलेंज, CAPTCHA, वास्तविक समय में व्यवहार का विश्लेषण करते हैं।

क्लाउडफ्लेयर

क्लाउडफ्लेयर कई सुरक्षा स्तरों का उपयोग करता है: ब्राउज़र इंटीग्रिटी चेक, JavaScript चैलेंज, CAPTCHA। बुनियादी सुरक्षा को बायपास करने के लिए सही TLS फिंगरप्रिंट और JavaScript को निष्पादित करना पर्याप्त है:

# विकल्प 1: cloudscraper (JS चैलेंजों को स्वचालित रूप से हल करना)
import cloudscraper

scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

response = scraper.get('https://protected-site.com')

# विकल्प 2: undetected-chromedriver (कठिन मामलों के लिए)
import undetected_chromedriver as uc

options = uc.ChromeOptions()
options.add_argument('--proxy-server=http://proxy:port')

driver = uc.Chrome(options=options)
driver.get('https://protected-site.com')

# चैलेंज पास करने की प्रतीक्षा
time.sleep(5)

# अनुरोधों के लिए कुकीज़ प्राप्त करना
cookies = driver.get_cookies()
session = requests.Session()
for cookie in cookies:
    session.cookies.set(cookie['name'], cookie['value'])

डेटा डोम

डेटा डोम वास्तविक समय में उपयोगकर्ता के व्यवहार का विश्लेषण करता है: माउस की गति, कीबोर्ड की आदतें, समय। बायपास करने के लिए एक पूर्ण ब्राउज़र की आवश्यकता होती है जो सक्रियता की नकल करता है:

from playwright.sync_api import sync_playwright
import random

def bypass_datadome(url, proxy=None):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # डेटा डोम हेडलेस का पता लगाता है
            proxy={'server': proxy} if proxy else None
        )
        
        context = browser.new_context(
            viewport={'width': 1920, 'height': 1080},
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
        )
        
        page = context.new_page()
        
        # स्वचालन को छिपाने के लिए स्क्रिप्ट का इंजेक्शन
        page.add_init_script("""
            Object.defineProperty(navigator, 'webdriver', {get: () => false});
            window.chrome = {runtime: {}};
        """)
        
        page.goto(url)
        
        # मानव व्यवहार की नकल करना
        time.sleep(random.uniform(2, 4))
        
        # यादृच्छिक माउस गति
        for _ in range(random.randint(5, 10)):
            page.mouse.move(
                random.randint(100, 1800),
                random.randint(100, 1000)
            )
            time.sleep(random.uniform(0.1, 0.3))
        
        # स्क्रॉलिंग
        page.evaluate(f"window.scrollTo(0, {random.randint(300, 800)})")
        time.sleep(random.uniform(1, 2))
        
        content = page.content()
        browser.close()
        
        return content

CAPTCHA

CAPTCHA को स्वचालित रूप से हल करने के लिए पहचानने वाली सेवाओं (2captcha, Anti-Captcha) का उपयोग करें या बचने की रणनीतियाँ अपनाएँ:

• अनुरोधों की आवृत्ति को उस स्तर तक कम करें जो CAPTCHA को ट्रिगर न करे
• अच्छी प्रतिष्ठा वाले स्वच्छ रिहायशी आईपी का उपयोग करें
• प्राधिकृत खातों के माध्यम से काम करें (इनका CAPTCHA थ्रेशोल्ड अधिक होता है)
• समय के अनुसार लोड वितरित करें (पीक समय से बचें)

निगरानी और ब्लॉकिंग का प्रबंधन

सर्वोत्तम प्रथाओं के साथ भी, ब्लॉकिंग अनिवार्य है। महत्वपूर्ण है कि उन्हें जल्दी से पहचानें और सही तरीके से प्रबंधित करें।

ब्लॉकिंग संकेत

पुनः प्रयास प्रणाली

import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_session_with_retries():
    """
    स्वचालित पुनः प्रयासों और त्रुटियों के प्रबंधन के साथ सत्र
    """
    session = requests.Session()
    
    retry_strategy = Retry(
        total=5,
        backoff_factor=2,  # 2, 4, 8, 16, 32 सेकंड
        status_forcelist=[429, 500, 502, 503, 504],
        method_whitelist=["GET", "POST"]
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

def safe_request(url, session, max_attempts=3):
    """
    ब्लॉकिंग के प्रबंधन के साथ अनुरोध
    """
    for attempt in range(max_attempts):
        try:
            response = session.get(url, timeout=15)
            
            # ब्लॉकिंग की जांच
            if response.status_code == 403:
                print(f"आईपी ब्लॉक किया गया। प्रॉक्सी बदल रहा हूँ...")
                # प्रॉक्सी बदलने की लॉजिक
                continue
                
            elif response.status_code == 429:
                wait_time = int(response.headers.get('Retry-After', 60))
                print(f"दर सीमा। {wait_time}s प्रतीक्षा कर रहा हूँ...")
                time.sleep(wait_time)
                continue
                
            elif 'captcha' in response.text.lower():
                print("CAPTCHA का पता चला")
                # CAPTCHA को हल करने या छोड़ने की लॉजिक
                return None
                
            return response
            
        except requests.exceptions.Timeout:
            print(f"प्रयास {attempt + 1} पर टाइमआउट")
            time.sleep(5 * (attempt + 1))
            
        except requests.exceptions.ProxyError:
            print("प्रॉक्सी त्रुटि। रोटेट कर रहा हूँ...")
            # प्रॉक्सी बदलना
            continue
            
    return None

लॉगिंग और विश्लेषण

रणनीति को अनुकूलित करने के लिए मेट्रिक्स को ट्रैक करें:

import logging
from collections import defaultdict
from datetime import datetime

class ScraperMetrics:
    def __init__(self):
        self.stats = {
            'total_requests': 0,
            'successful': 0,
            'rate_limited': 0,
            'blocked': 0,
            'captcha': 0,
            'errors': 0,
            'proxy_failures': defaultdict(int)
        }
        
    def log_request(self, status, proxy=None):
        self.stats['total_requests'] += 1
        
        if status == 200:
            self.stats['successful'] += 1
        elif status == 429:
            self.stats['rate_limited'] += 1
        elif status == 403:
            self.stats['blocked'] += 1
            if proxy:
                self.stats['proxy_failures'][proxy] += 1
                
    def get_success_rate(self):
        if self.stats['total_requests'] == 0:
            return 0
        return (self.stats['successful'] / self.stats['total_requests']) * 100
        
    def print_report(self):
        print(f"\n=== स्क्रैपिंग रिपोर्ट ===")
        print(f"कुल अनुरोध: {self.stats['total_requests']}")
        print(f"सफलता दर: {self.get_success_rate():.2f}%")
        print(f"दर सीमा: {self.stats['rate_limited']}")
        print(f"ब्लॉक किया गया: {self.stats['blocked']}")
        print(f"CAPTCHA: {self.stats['captcha']}")
        
        if self.stats['proxy_failures']:
            print(f"\nसमस्या वाले प्रॉक्सी:")
            for proxy, count in sorted(
                self.stats['proxy_failures'].items(), 
                key=lambda x: x[1], 
                reverse=True
            )[:5]:
                print(f"  {proxy}: {count} विफलताएँ")

# उपयोग
metrics = ScraperMetrics()

for url in urls:
    response = safe_request(url, session)
    if response:
        metrics.log_request(response.status_code, current_proxy)
    
metrics.print_report()

निष्कर्ष

सुरक्षा उपायों के बावजूद, बड़े अनुरोधों पर ब्लॉकिंग से बचना चुनौतीपूर्ण हो सकता है। सही रणनीतियों और उपकरणों का उपयोग करके, आप अपने स्क्रैपिंग प्रयासों को अधिक प्रभावी और सुरक्षित बना सकते हैं।