यदि प्रॉक्सी लगातार प्रतिबंधित हो रही है तो क्या करें: निदान और समस्या समाधान के लिए संपूर्ण गाइड

लगातार प्रॉक्सी ब्लॉकेज पार्सिंग, ऑटोमेशन और कई खातों के साथ काम करते समय सबसे आम समस्याओं में से एक है। इस लेख में हम समझाएंगे कि ऐसा क्यों होता है और समस्या को व्यवस्थित रूप से कैसे हल करें, न कि बस आशा के साथ प्रदाताओं को बदलते रहें।

प्रॉक्सी को वास्तव में क्यों प्रतिबंधित किया जाता है

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

IP-प्रतिष्ठा और ब्लैकलिस्ट

प्रत्येक IP-पते की एक प्रतिष्ठा है जो इसके उपयोग के इतिहास के आधार पर बनती है। यदि पता पहले स्पैम, DDoS-हमले या बड़े पैमाने पर पार्सिंग के लिए उपयोग किया गया था, तो यह Spamhaus, SORBS या विशिष्ट सेवाओं की मालिकाना सूचियों जैसे डेटाबेस में प्रवेश करता है। जब आप ऐसे IP के माध्यम से कनेक्ट करते हैं, तो सिस्टम तुरंत आपके प्रति संदेह करता है।

डेटा-सेंटर प्रॉक्सी इस समस्या के लिए विशेष रूप से प्रवण हैं। पूरे IP सबनेट को "होस्टिंग" के रूप में चिह्नित किया जा सकता है, और उनसे कोई भी ट्रैफिक स्वचालित रूप से बढ़ी हुई जांच स्तर प्राप्त करता है। Amazon AWS, Google Cloud, DigitalOcean — उनकी IP श्रेणियां अच्छी तरह से ज्ञात हैं और अक्सर निवारक रूप से अवरुद्ध होती हैं।

आप IPQualityScore, Scamalytics या AbuseIPDB जैसी सेवाओं के माध्यम से IP प्रतिष्ठा की जांच कर सकते हैं। यदि आपकी प्रॉक्सी 75 से अधिक fraud score दिखाती है, तो समस्या यही है — प्रदाता बदलें या प्रॉक्सी प्रकार बदलें।

अनुरोध पैटर्न

एक इंसान प्रति सेकंड 100 अनुरोध नहीं करता। एक इंसान 2 सेकंड की परिपूर्ण नियमितता के साथ पृष्ठों के बीच नेविगेट नहीं करता। एक इंसान चित्र, CSS और JavaScript को अनदेखा नहीं करता, केवल HTML का अनुरोध करता है। एंटीफ्रॉड सिस्टम बिल्कुल इन पैटर्न का विश्लेषण करते हैं, और "मानव" व्यवहार से कोई भी विचलन ब्लॉकेज का जोखिम बढ़ाता है।

अनुरोधों के बीच समय के आंकड़े विशेष रूप से बताने वाले हैं। यदि आपके पास स्थिर अंतराल है — यह स्वचालन का स्पष्ट संकेत है। यादृच्छिक विलंब जोड़ना (उदाहरण के लिए, 1 से 5 सेकंड तक) पहचान की संभावना को काफी कम करता है।

मेटाडेटा असंगति

जब आपका User-Agent कहता है कि आप Windows पर Chrome का उपयोग कर रहे हैं, लेकिन HTTP-हेडर Python requests की विशेषताओं को उजागर करते हैं — यह एक लाल झंडा है। जब IP-पता जर्मनी में भू-स्थित है, लेकिन ब्राउजर भाषा सेटिंग्स रूसी को इंगित करती हैं — एक और लाल झंडा। जब JavaScript में समय क्षेत्र IP के भूगोल से मेल नहीं खाता — तीसरा झंडा।

ऐसी असंगतियों का संचय सिस्टम को कनेक्शन को संदिग्ध के रूप में वर्गीकृत करने के लिए प्रेरित करता है और सुरक्षात्मक उपाय लागू करता है: कैप्चा से लेकर पूर्ण IP ब्लॉकेज तक।

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

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

यदि आप प्रॉक्सी बदलते हैं, लेकिन फिंगरप्रिंट समान रहता है, तो सिस्टम समझता है कि यह वही उपयोगकर्ता है। और यदि एक फिंगरप्रिंट कम समय में सैकड़ों विभिन्न IP से दिखाई देता है — यह स्वचालन का स्पष्ट संकेत है।

निदान: ब्लॉकेज का कारण कैसे समझें

सेटिंग्स को अंधाधुंध बदलने से पहले, निदान करें। यह घंटों के प्रयोग को बचाएगा और समस्या का वास्तविक कारण खोजने में मदद करेगा। निदान के लिए एक व्यवस्थित दृष्टिकोण प्रभावी समाधान की कुंजी है।

चरण 1: प्रॉक्सी को स्वयं जांचें

अपनी मुख्य स्क्रिप्ट से स्वतंत्र रूप से प्रॉक्सी की बुनियादी कार्यक्षमता की जांच करके शुरू करें:

import requests

proxy = {
    "http": "http://user:pass@proxy-server:port",
    "https": "http://user:pass@proxy-server:port"
}

# प्रॉक्सी की बुनियादी कार्यक्षमता की जांच
try:
    response = requests.get("https://httpbin.org/ip", proxies=proxy, timeout=10)
    print(f"प्रॉक्सी के माध्यम से IP: {response.json()['origin']}")
except Exception as e:
    print(f"कनेक्शन त्रुटि: {e}")

# वास्तविक IP लीक की जांच करें
response = requests.get("https://browserleaks.com/ip", proxies=proxy)
# अपने वास्तविक IP के साथ तुलना करें

यदि प्रॉक्सी सरल अनुरोधों पर भी काम नहीं करती है — समस्या प्रॉक्सी या क्रेडेंशियल में है। कनेक्शन प्रारूप की सही जांच करें, प्रदाता के खाते में शेष राशि की जांच करें और सीमाएं देखें।

चरण 2: IP प्रतिष्ठा की जांच करें

व्यापक मूल्यांकन के लिए कई सेवाओं का उपयोग करें:

# प्रॉक्सी IP प्राप्त करें
proxy_ip = requests.get("https://api.ipify.org", proxies=proxy).text

# इन सेवाओं पर जांच करें:
# https://www.ipqualityscore.com/free-ip-lookup-proxy-vpn-test
# https://scamalytics.com/ip/{proxy_ip}
# https://www.abuseipdb.com/check/{proxy_ip}
# https://whatismyipaddress.com/ip/{proxy_ip}

print(f"ऊपर दी गई सेवाओं पर IP {proxy_ip} की जांच करें")

निम्नलिखित संकेतकों पर ध्यान दें: fraud score (50 से कम होना चाहिए), IP प्रकार (डेटा-सेंटर से बेहतर आवासीय), ब्लैकलिस्ट में उपस्थिति। यदि IP को VPN/Proxy के रूप में चिह्नित किया गया है — कई साइटें शुरुआत से ही इसके प्रति संदेह करेंगी।

चरण 3: समस्या को अलग करें

विभिन्न लक्ष्य साइटों पर समान प्रॉक्सी आजमाएं। यदि ब्लॉकेज हर जगह होता है — समस्या प्रॉक्सी या आपकी सेटिंग में है। यदि केवल एक विशिष्ट साइट पर — समस्या उस साइट की सुरक्षा या आपके व्यवहार में है।

साथ ही, एक साइट पर विभिन्न प्रॉक्सी आजमाएं। यदि सभी अवरुद्ध हैं — समस्या प्रॉक्सी में नहीं है, बल्कि आपकी स्क्रिप्ट, फिंगरप्रिंट या व्यवहार पैटर्न में है। यह एक महत्वपूर्ण परीक्षण है जिसे कई लोग छोड़ देते हैं।

चरण 4: सर्वर प्रतिक्रिया विश्लेषण

विभिन्न प्रकार के ब्लॉकेज अलग-अलग तरीकों से प्रकट होते हैं। उन्हें अलग करना सीखें:

def analyze_response(response):
    status = response.status_code
    
    if status == 403:
        print("पहुंच निषिद्ध है — संभवतः IP ब्लैकलिस्ट में है")
    elif status == 429:
        print("बहुत अधिक अनुरोध — आवृत्ति कम करें")
    elif status == 503:
        print("सेवा अनुपलब्ध है — संभवतः DDoS सुरक्षा")
    elif status == 407:
        print("प्रॉक्सी प्राधिकरण आवश्यक है — क्रेडेंशियल की जांच करें")
    elif "captcha" in response.text.lower():
        print("कैप्चा पाया गया — बॉट संदेह")
    elif "blocked" in response.text.lower():
        print("स्पष्ट ब्लॉकेज — IP बदलें और दृष्टिकोण पुनर्विचार करें")
    elif len(response.text) < 1000:
        print("संदिग्ध रूप से छोटी प्रतिक्रिया — संभवतः स्टब")
    else:
        print(f"स्थिति {status}, प्रतिक्रिया लंबाई: {len(response.text)}")

सही रोटेशन: आवृत्ति, तर्क, कार्यान्वयन

प्रॉक्सी रोटेशन केवल "अधिक बार IP बदलना" नहीं है। गलत रोटेशन इसकी अनुपस्थिति से अधिक नुकसान कर सकता है। आइए विभिन्न रणनीतियों और उनके उपयोग के समय पर विचार करें।

रणनीति 1: अनुरोध संख्या के आधार पर रोटेशन

सबसे सरल दृष्टिकोण — एक निश्चित संख्या में अनुरोधों के बाद IP बदलना। पार्सिंग के लिए उपयुक्त जहां सत्र की आवश्यकता नहीं है:

import random

class ProxyRotator:
    def __init__(self, proxy_list, requests_per_proxy=50):
        self.proxies = proxy_list
        self.requests_per_proxy = requests_per_proxy
        self.current_proxy = None
        self.request_count = 0
    
    def get_proxy(self):
        if self.current_proxy is None or self.request_count >= self.requests_per_proxy:
            # अनुरोधों की संख्या में यादृच्छिकता जोड़ें
            self.requests_per_proxy = random.randint(30, 70)
            self.current_proxy = random.choice(self.proxies)
            self.request_count = 0
        
        self.request_count += 1
        return self.current_proxy

# उपयोग
rotator = ProxyRotator(proxy_list)
for url in urls_to_scrape:
    proxy = rotator.get_proxy()
    response = requests.get(url, proxies={"http": proxy, "https": proxy})

अनुरोधों की संख्या में यादृच्छिकता पर ध्यान दें। एक निश्चित संख्या (उदाहरण के लिए, बिल्कुल 50) एक पैटर्न है जिसे पहचाना जा सकता है। यादृच्छिक श्रेणी व्यवहार को कम अनुमानित बनाती है।

रणनीति 2: समय के आधार पर रोटेशन

उन कार्यों के लिए जहां सत्र महत्वपूर्ण है (उदाहरण के लिए, खातों के साथ काम), IP को समय से जोड़ना बेहतर है:

import time
import random

class TimeBasedRotator:
    def __init__(self, proxy_list, min_minutes=10, max_minutes=30):
        self.proxies = proxy_list
        self.min_seconds = min_minutes * 60
        self.max_seconds = max_minutes * 60
        self.current_proxy = None
        self.rotation_time = 0
    
    def get_proxy(self):
        current_time = time.time()
        
        if self.current_proxy is None or current_time >= self.rotation_time:
            self.current_proxy = random.choice(self.proxies)
            # अगले रोटेशन तक यादृच्छिक अंतराल
            interval = random.randint(self.min_seconds, self.max_seconds)
            self.rotation_time = current_time + interval
            print(f"नई प्रॉक्सी, अगला रोटेशन {interval//60} मिनट में")
        
        return self.current_proxy

रणनीति 3: खातों के लिए स्टिकी सेशन

कई खातों के साथ काम करते समय, यह महत्वपूर्ण है कि प्रत्येक खाता एक स्थिर IP का उपयोग करे। लॉगिन किए गए खाते के लिए IP परिवर्तन बैन का एक निश्चित तरीका है:

class AccountProxyManager:
    def __init__(self, proxy_pool):
        self.proxy_pool = proxy_pool
        self.account_proxies = {}  # account_id -> proxy
        self.used_proxies = set()
    
    def get_proxy_for_account(self, account_id):
        # यदि खाते को पहले से प्रॉक्सी असाइन की गई है — इसे वापस करें
        if account_id in self.account_proxies:
            return self.account_proxies[account_id]
        
        # एक मुक्त प्रॉक्सी खोजें
        available = [p for p in self.proxy_pool if p not in self.used_proxies]
        
        if not available:
            raise Exception("नए खातों के लिए कोई मुक्त प्रॉक्सी नहीं है")
        
        proxy = random.choice(available)
        self.account_proxies[account_id] = proxy
        self.used_proxies.add(proxy)
        
        return proxy
    
    def release_account(self, account_id):
        """खाता हटाने पर प्रॉक्सी मुक्त करता है"""
        if account_id in self.account_proxies:
            proxy = self.account_proxies.pop(account_id)
            self.used_proxies.discard(proxy)

# उपयोग
manager = AccountProxyManager(residential_proxy_list)

for account in accounts:
    proxy = manager.get_proxy_for_account(account.id)
    # इस खाते की सभी कार्रवाइयां एक IP के माध्यम से जाती हैं

रणनीति 4: अनुकूली रोटेशन

सबसे उन्नत दृष्टिकोण — लक्ष्य साइट से संकेतों के जवाब में प्रॉक्सी बदलना:

class AdaptiveRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current_proxy = random.choice(proxy_list)
        self.proxy_scores = {p: 100 for p in proxy_list}  # प्रॉक्सी का प्रारंभिक "स्वास्थ्य"
    
    def get_proxy(self):
        return self.current_proxy
    
    def report_result(self, success, response_code=200):
        """प्रत्येक अनुरोध के बाद कॉल किया जाता है"""
        if success and response_code == 200:
            # सफल अनुरोध — स्कोर थोड़ा बढ़ाएं
            self.proxy_scores[self.current_proxy] = min(100, 
                self.proxy_scores[self.current_proxy] + 1)
        elif response_code == 429:
            # दर सीमा — स्कोर कम करें और रोटेट करें
            self.proxy_scores[self.current_proxy] -= 30
            self._rotate()
        elif response_code == 403:
            # बैन — स्कोर शून्य करें और रोटेट करें
            self.proxy_scores[self.current_proxy] = 0
            self._rotate()
        elif response_code == 503:
            # संभावित सुरक्षा — स्कोर कम करें और रोटेट करें
            self.proxy_scores[self.current_proxy] -= 20
            self._rotate()
    
    def _rotate(self):
        # सर्वोत्तम स्कोर वाली प्रॉक्सी चुनें
        available = [(p, s) for p, s in self.proxy_scores.items() if s > 20]
        if not available:
            # सभी प्रॉक्सी "मर गई" हैं — स्कोर रीसेट करें
            self.proxy_scores = {p: 50 for p in self.proxies}
            available = list(self.proxy_scores.items())
        
        # स्कोर के आधार पर भारित चयन
        self.current_proxy = max(available, key=lambda x: x[1])[0]
        print(f"स्कोर {self.proxy_scores[self.current_proxy]} के साथ प्रॉक्सी पर रोटेशन")

ब्राउजर फिंगरप्रिंट और ब्लॉकेज में इसकी भूमिका

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

फिंगरप्रिंट किससे बना है

आधुनिक फिंगरप्रिंट में दर्जनों पैरामीटर शामिल हैं। यहाँ मुख्य श्रेणियां हैं:

फिंगरप्रिंट और IP का संगति

यह महत्वपूर्ण है कि फिंगरप्रिंट IP के भूगोल से मेल खाए। यदि प्रॉक्सी जर्मनी में है, तो फिंगरप्रिंट एक जर्मन उपयोगकर्ता की तरह दिखना चाहिए:

// असंगति का उदाहरण (बुरा):
// IP: जर्मनी
// Timezone: America/New_York
// Languages: ["ru-RU", "ru"]
// यह संदेह पैदा करेगा

// संगत फिंगरप्रिंट (अच्छा):
// IP: जर्मनी
// Timezone: Europe/Berlin
// Languages: ["de-DE", "de", "en-US", "en"]

फिंगरप्रिंट प्रबंधन के लिए उपकरण

गंभीर काम के लिए विशेष उपकरण का उपयोग करें:

Stealth के साथ Playwright:

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={"server": "http://proxy:port", "username": "user", "password": "pass"}
    )
    
    context = browser.new_context(
        viewport={"width": 1920, "height": 1080},
        locale="de-DE",
        timezone_id="Europe/Berlin",
        geolocation={"latitude": 52.52, "longitude": 13.405},
        permissions=["geolocation"]
    )
    
    page = context.new_page()
    stealth_sync(page)  # Stealth-पैच लागू करें
    
    page.goto("https://target-site.com")

puppeteer-extra के साथ Puppeteer:

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

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    args: [`--proxy-server=http://proxy:port`]
});

const page = await browser.newPage();

// Timezone को फिर से परिभाषित करें
await page.evaluateOnNewDocument(() => {
    Object.defineProperty(Intl.DateTimeFormat.prototype, 'resolvedOptions', {
        value: function() {
            return { timeZone: 'Europe/Berlin' };
        }
    });
});

एंटीडिटेक्ट ब्राउजर

खातों के साथ काम करने के लिए अक्सर एंटीडिटेक्ट ब्राउजर (Multilogin, GoLogin, Dolphin Anty और अन्य) का उपयोग किया जाता है। वे अद्वितीय फिंगरप्रिंट के साथ अलग-अलग प्रोफाइल बनाने की अनुमति देते हैं। प्रत्येक प्रोफाइल में अपने पैरामीटर, कुकीज़, localStorage का एक सेट है — पूरी तरह से अलग-थलग वातावरण।

एंटीडिटेक्ट का लाभ यह है कि वे फिंगरप्रिंट समस्या को "बॉक्स से बाहर" हल करते हैं। नुकसान — लागत और स्वचालन की जटिलता (हालांकि कई के पास API है)।

व्यवहार पैटर्न: बॉट की तरह न दिखने के लिए

यहां तक कि आदर्श फिंगरप्रिंट और स्वच्छ IP के साथ, आप गैर-मानवीय व्यवहार के कारण बैन प्राप्त कर सकते हैं। आधुनिक सिस्टम केवल तकनीकी पैरामीटर नहीं, बल्कि साइट के साथ इंटरैक्शन के पैटर्न का विश्लेषण करते हैं।

समय विलंब

एक इंसान निरंतर अंतराल के साथ अनुरोध नहीं करता। सामान्य वितरण के साथ यादृच्छिक विलंब जोड़ें:

import random
import time
import numpy as np

def human_delay(min_sec=1, max_sec=5, mean=2.5):
    """
    मानव-जैसा विलंब उत्पन्न करता है।
    लॉगनॉर्मल वितरण का उपयोग करता है — 
    अधिकांश विलंब छोटे होते हैं, लेकिन कभी-कभी लंबे होते हैं।
    """
    delay = np.random.lognormal(mean=np.log(mean), sigma=0.5)
    delay = max(min_sec, min(max_sec, delay))
    return delay

def human_typing_delay():
    """कीस्ट्रोक के बीच विलंब"""
    return random.uniform(0.05, 0.25)

# उपयोग
for url in urls:
    response = requests.get(url, proxies=proxy)
    process(response)
    time.sleep(human_delay())  # अनुरोधों के बीच यादृच्छिक विराम

नेविगेशन का अनुकरण

एक इंसान सीधे लिंक से सीधे उत्पाद पृष्ठ पर नहीं जाता। वह मुख्य पृष्ठ पर जाता है, खोज का उपयोग करता है, श्रेणियां देखता है। इस पथ का अनुकरण करें:

async def human_like_navigation(page, target_url):
    """लक्ष्य पृष्ठ पर मानव-जैसे नेविगेशन का अनुकरण करता है"""
    
    # 1. मुख्य पृष्ठ पर जाएं
    await page.goto("https://example.com")
    await page.wait_for_timeout(random.randint(2000, 4000))
    
    # 2. कभी-कभी मुख्य पृष्ठ को स्क्रॉल करें
    if random.random() > 0.5:
        await page.evaluate("window.scrollBy(0, 300)")
        await page.wait_for_timeout(random.randint(1000, 2000))
    
    # 3. खोज या नेविगेशन का उपयोग करें
    if random.random() > 0.3:
        search_box = await page.query_selector('input[type="search"]')
        if search_box:
            await search_box.type("search query", delay=100)
            await page.keyboard.press("Enter")
            await page.wait_for_timeout(random.randint(2000, 4000))
    
    # 4. लक्ष्य पृष्ठ पर जाएं
    await page.goto(target_url)
    
    # 5. एक इंसान की तरह पृष्ठ को स्क्रॉल करें
    await human_scroll(page)

async def human_scroll(page):
    """मानव स्क्रॉलिंग का अनुकरण करता है"""
    scroll_height = await page.evaluate("document.body.scrollHeight")
    current_position = 0
    
    while current_position < scroll_height * 0.7:  # अंत तक नहीं
        scroll_amount = random.randint(200, 500)
        await page.evaluate(f"window.scrollBy(0, {scroll_amount})")
        current_position += scroll_amount
        await page.wait_for_timeout(random.randint(500, 1500))

माउस आंदोलन

कुछ सिस्टम माउस आंदोलन को ट्रैक करते हैं। बिंदु A से बिंदु B तक सीधी गति — बॉट का संकेत। एक इंसान माइक्रो-सुधार के साथ एक वक्र में माउस को हिलाता है:

import bezier
import numpy as np

def generate_human_mouse_path(start, end, num_points=50):
    """
    बेजियर वक्र का उपयोग करके मानव-जैसी माउस पथ उत्पन्न करता है
    थोड़ी शोर के साथ।
    """
    # बेजियर वक्र के लिए नियंत्रण बिंदु
    control1 = (
        start[0] + (end[0] - start[0]) * random.uniform(0.2, 0.4) + random.randint(-50, 50),
        start[1] + (end[1] - start[1]) * random.uniform(0.2, 0.4) + random.randint(-50, 50)
    )
    control2 = (
        start[0] + (end[0] - start[0]) * random.uniform(0.6, 0.8) + random.randint(-50, 50),
        start[1] + (end[1] - start[1]) * random.uniform(0.6, 0.8) + random.randint(-50, 50)
    )
    
    # बेजियर वक्र बनाएं
    nodes = np.asfortranarray([
        [start[0], control1[0], control2[0], end[0]],
        [start[1], control1[1], control2[1], end[1]]
    ])
    curve = bezier.Curve(nodes, degree=3)
    
    # वक्र पर बिंदु उत्पन्न करें
    points = []
    for t in np.linspace(0, 1, num_points):
        point = curve.evaluate(t)
        # माइक्रो-शोर जोड़ें
        x = point[0][0] + random.uniform(-2, 2)
        y = point[1][0] + random.uniform(-2, 2)
        points.append((x, y))
    
    return points

async def human_click(page, selector):
    """मानव-जैसी माउस गति के साथ एक तत्व पर क्लिक करता है"""
    element = await page.query_selector(selector)
    box = await element.bounding_box()
    
    # लक्ष्य बिंदु — केंद्र नहीं, बल्कि तत्व के अंदर यादृच्छिक बिंदु
    target_x = box['x'] + random.uniform(box['width'] * 0.2, box['width'] * 0.8)
    target_y = box['y'] + random.uniform(box['height'] * 0.2, box['height'] * 0.8)
    
    # माउस की वर्तमान स्थिति (या यादृच्छिक प्रारंभिक)
    start_x = random.randint(0, 1920)
    start_y = random.randint(0, 1080)
    
    # पथ उत्पन्न करें
    path = generate_human_mouse_path((start_x, start_y), (target_x, target_y))
    
    # पथ के साथ माउस को हिलाएं
    for x, y in path:
        await page.mouse.move(x, y)
        await page.wait_for_timeout(random.randint(5, 20))
    
    # क्लिक से पहले थोड़ा विराम
    await page.wait_for_timeout(random.randint(50, 150))
    await page.mouse.click(target_x, target_y)

संसाधन लोडिंग

एक वास्तविक ब्राउजर केवल HTML नहीं, बल्कि CSS, JavaScript, चित्र, फ़ॉन्ट भी लोड करता है। यदि आप requests का उपयोग कर रहे हैं और केवल HTML का अनुरोध कर रहे हैं — यह संदिग्ध है। headless-ब्राउजर के साथ काम करते समय यह समस्या स्वचालित रूप से हल हो जाती है, लेकिन HTTP-क्लाइंट के साथ इस पर विचार करना आवश्यक है।

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

विभिन्न प्रकार की प्रॉक्सी के विभिन्न विशेषताएं हैं और विभिन्न कार्यों के लिए उपयुक्त हैं। गलत विकल्प ब्लॉकेज का एक सामान्य कारण है।

डेटा-सेंटर प्रॉक्सी

डेटा-सेंटर प्रॉक्सी होस्टिंग प्रदाताओं से संबंधित IP-पते हैं। उन्हें AS (स्वायत्त प्रणाली) की सदस्यता से बड़े डेटा-सेंटर द्वारा पहचाना जा सकता है।

फायदे:

• उच्च गति और स्थिरता
• कम लागत
• बड़े IP पूल

नुकसान:

• आसानी से पहचाने जाते हैं
• अक्सर ब्लैकलिस्ट में होते हैं
• गंभीर सुरक्षा वाली साइटों के लिए उपयुक्त नहीं

के लिए उपयुक्त: SEO-उपकरण, उपलब्धता जांच, कड़ी सुरक्षा के बिना API के साथ काम, परीक्षण।

आवासीय प्रॉक्सी

आवासीय प्रॉक्सी वास्तविक उपयोगकर्ताओं के IP-पते हैं, जो भागीदारी कार्यक्रमों या ऐप्स में SDK के माध्यम से प्रदान किए जाते हैं। वे सामान्य इंटरनेट प्रदाताओं (ISP) से संबंधित हैं।

फायदे:

• सामान्य उपयोगकर्ताओं की तरह दिखते हैं
• कम fraud score
• व्यापक भूगोल
• पहचान करना मुश्किल

नुकसान:

• अधिक लागत (ट्रैफिक के लिए भुगतान)
• गति अंतिम उपयोगकर्ता पर निर्भर करती है
• IP "जा सकते हैं" (उपयोगकर्ता डिवाइस बंद कर देता है)

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

मोबाइल प्रॉक्सी

मोबाइल प्रॉक्सी मोबाइल ऑपरेटरों के IP-पते हैं (MTS, Beeline, Megafon और अन्य देशों में समकक्ष)। उनके पास CGNAT तकनीक के कारण विशेष स्थिति है।

फायदे:

• साइटों की ओर से अधिकतम विश्वास
• एक IP हजारों वास्तविक उपयोगकर्ताओं द्वारा उपयोग किया जाता है — बैन करना मुश्किल
• खातों के साथ काम के लिए आदर्श
• अनुरोध पर IP परिवर्तन (नेटवर्क से पुनः कनेक्ट)

नुकसान:

• सबसे अधिक लागत
• सीमित गति
• भूगोल की कम पसंद

के लिए उपयुक्त: मल्टी-अकाउंटिंग, Instagram/Facebook/TikTok के साथ काम, खातों का पंजीकरण, उच्च बैन जोखिम वाले कोई भी कार्य।

तुलनात्मक तालिका

सुरक्षा बाईपास के उन्नत तकनीकें

जब बुनियादी तरीके काम नहीं करते हैं, तो अधिक जटिल तकनीकों का उपयोग करना पड़ता है। आइए कुछ उन्नत दृष्टिकोणों पर विचार करें।

Cloudflare और समान सुरक्षा के साथ काम करना

Cloudflare, Akamai, PerimeterX — ये सिस्टम ब्राउजर को सत्यापित करने के लिए JavaScript-चुनौतियों का उपयोग करते हैं। एक साधारण HTTP-अनुरोध काम नहीं करेगा। समाधान के विकल्प:

1. वास्तविक ब्राउजर का उपयोग:

from playwright.sync_api import sync_playwright

def bypass_cloudflare(url, proxy):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # कभी-कभी headless पहचाना जाता है
            proxy={"server": proxy}
        )
        
        page = browser.new_page()
        page.goto(url)
        
        # जांच पास करने के लिए प्रतीक्षा करें (आमतौर पर 5-10 सेकंड)
        page.wait_for_timeout(10000)
        
        # जांचें कि क्या हम पास हुए
        if "challenge" not in page.url:
            # बाद के अनुरोधों के लिए कुकीज़ सहेजें
            cookies = page.context.cookies()
            return cookies
        
        browser.close()
        return None

2. तैयार समाधान का उपयोग:

# cloudscraper — Cloudflare को बाईपास करने के लिए लाइब्रेरी
import cloudscraper

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

scraper.proxies = {"http": proxy, "https": proxy}
response = scraper.get("https://protected-site.com")

कैप्चा का समाधान

यदि साइट कैप्चा दिखाती है, तो कई दृष्टिकोण हैं:

मान्यता सेवाएं: 2Captcha, Anti-Captcha, CapMonster। वे आपके लिए कैप्चा को हल करते हैं