← Back to Blog
RUENZHESARPTDEFRJAKOITTRIDVIFAHI

क्लाउडफ्लेयर डिटेक्शन को प्रॉक्सी का उपयोग करके कैसे बायपास करें

Cloudflare आपके अनुरोधों को प्रॉक्सी के माध्यम से ब्लॉक कर रहा है? हम तकनीकी तरीकों का विश्लेषण करते हैं जो डिटेक्शन को बायपास करते हैं: सही TLS सेटअप से लेकर हेडलेस ब्राउज़रों के उपयोग तक, वास्तविक उदाहरणों के साथ।

📅December 17, 2025
```html

प्रॉक्सी के माध्यम से Cloudflare की पहचान को बाईपास करने के 7 सिद्ध तरीके

Cloudflare 20% से अधिक वेब ट्रैफ़िक को संभालता है और बॉट्स के खिलाफ एक बहुस्तरीय सुरक्षा प्रणाली का उपयोग करता है। प्रॉक्सी सर्वरों के माध्यम से काम करते समय कैप्चा या ब्लॉक होने की संभावना कई गुना बढ़ जाती है। इस मार्गदर्शिका में, हम पहचान के तकनीकी पहलुओं और 2024 में काम करने वाले बाईपास के व्यावहारिक तरीकों पर चर्चा करेंगे।

Cloudflare प्रॉक्सी और बॉट्स को कैसे पहचानता है

Cloudflare एक व्यापक विश्लेषण प्रणाली का उपयोग करता है जो प्रत्येक अनुरोध के दर्जनों मापदंडों की जांच करता है। पहचान तंत्र को समझना सफल बाईपास का पहला कदम है।

पहचान के मुख्य तरीके

TLS फिंगरप्रिंटिंग: Cloudflare SSL/TLS हैंडशेक के मापदंडों (साइफर सूट, एक्सटेंशन, उनके अनुक्रम) का विश्लेषण करता है। प्रत्येक HTTP क्लाइंट का एक अद्वितीय "फिंगरप्रिंट" होता है। उदाहरण के लिए, Python requests OpenSSL का उपयोग करता है जिसमें एक विशिष्ट साइफर सेट होता है, जिसे Chrome या Firefox से आसानी से अलग किया जा सकता है।

अनुरोध का विश्लेषण करते समय, Cloudflare TLS फिंगरप्रिंट को निर्दिष्ट यूजर-एजेंट के साथ मिलाता है। यदि आप Chrome 120 निर्दिष्ट करते हैं, लेकिन TLS मापदंड Python requests के अनुरूप हैं - तो यह बॉट की तात्कालिक पहचान है।

जांच मापदंड क्या विश्लेषित किया जाता है पहचान का जोखिम
TLS फिंगरप्रिंट साइफर सूट, एक्सटेंशन, TLS संस्करण उच्च
HTTP/2 फिंगरप्रिंट हेडर का क्रम, SETTINGS फ्रेम उच्च
IP प्रतिष्ठा IP का इतिहास, डेटा सेंटर से संबंधितता मध्यम
JavaScript चुनौती JS का निष्पादन, कैनवास फिंगरप्रिंट, WebGL उच्च
व्यवहारिक विश्लेषण अनुरोधों के पैटर्न, समय, माउस मूवमेंट्स मध्यम

2023 से, Cloudflare व्यवहारिक पैटर्न के विश्लेषण के लिए मशीन लर्निंग का सक्रिय रूप से उपयोग कर रहा है। प्रणाली केवल तकनीकी मापदंडों को नहीं बल्कि अनुरोधों के बीच समय अंतराल, उपयोगकर्ता की क्रियाओं का क्रम, माउस मूवमेंट और पृष्ठ स्क्रॉलिंग को भी ट्रैक करती है।

TLS फिंगरप्रिंट को छिपाना

TLS फिंगरप्रिंटिंग - बॉट्स की पहचान का सबसे प्रभावी तरीका है। मानक HTTP क्लाइंट (requests, curl, axios) एक ऐसा फिंगरप्रिंट बनाते हैं जिसे वास्तविक ब्राउज़र के साथ भ्रमित नहीं किया जा सकता। समाधान - ब्राउज़रों के TLS व्यवहार की नकल करने वाले विशेष पुस्तकालयों का उपयोग करना।

curl-impersonate का उपयोग

curl-impersonate पुस्तकालय - curl का एक संशोधित संस्करण है जो लोकप्रिय ब्राउज़रों के TLS और HTTP/2 फिंगरप्रिंट को सटीक रूप से कॉपी करता है। यह Chrome, Firefox, Safari और Edge का समर्थन करता है। 

# curl-impersonate स्थापित करना
git clone https://github.com/lwthiker/curl-impersonate
cd curl-impersonate
make chrome-build

# Chrome 120 की नकल के साथ उपयोग
curl_chrome120 -x http://username:password@proxy.example.com:8080 \
  -H "Accept-Language: en-US,en;q=0.9" \
  https://example.com

Python: tls-client पुस्तकालय

Python के लिए एक tls-client नामक लिपि है, जो curl-impersonate का उपयोग करती है और requests के समान इंटरफ़ेस प्रदान करती है। 

import tls_client

# Chrome 120 के फिंगरप्रिंट के साथ सत्र बनाना
session = tls_client.Session(
    client_identifier="chrome_120",
    random_tls_extension_order=True
)

# प्रॉक्सी सेट करना
proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080'
}

# अनुरोध करना
response = session.get(
    'https://example.com',
    proxies=proxies,
    headers={
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;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'
    }
)

print(response.status_code)

महत्वपूर्ण: tls-client का उपयोग करते समय, यह अत्यंत महत्वपूर्ण है कि हेडर में User-Agent चुने गए client_identifier के अनुरूप हो। असंगति तात्कालिक पहचान का कारण बनेगी।

TLS फिंगरप्रिंट की जांच

पार्सिंग शुरू करने से पहले, अपने TLS फिंगरप्रिंट की जांच करना अनुशंसित है। विश्लेषण के लिए tls.peet.ws या ja3er.com जैसी सेवाओं का उपयोग करें। 

# फिंगरप्रिंट की जांच
response = session.get('https://tls.peet.ws/api/all')
print(response.json()['tls']['ja3'])

# वास्तविक Chrome के फिंगरप्रिंट के साथ तुलना करें:
# https://kawayiyi.com/tls-fingerprint-database/

HTTP हेडर की सही सेटिंग

सही TLS फिंगरप्रिंट के साथ भी, गलत HTTP हेडर बॉट का पता लगाते हैं। Cloudflare न केवल हेडरों की उपस्थिति का विश्लेषण करता है, बल्कि उनके क्रम, मानों का प्रारूप और तार्किक संगति की भी जांच करता है।

Chrome के लिए अनिवार्य हेडर 

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,image/apng,*/*;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',
    'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
    'Sec-Ch-Ua-Mobile': '?0',
    'Sec-Ch-Ua-Platform': '"Windows"',
    'Cache-Control': 'max-age=0'
}

Sec-Ch-Ua-* हेडर Chrome 89 में पेश किए गए थे और ये Client Hints API का हिस्सा हैं। आधुनिक User-Agent का उपयोग करते समय इनका अभाव बॉट का स्पष्ट संकेत है।

हेडरों का क्रम महत्वपूर्ण है

HTTP/2 में, हेडरों का क्रम प्रत्येक ब्राउज़र के लिए निश्चित है। Python requests और अन्य मानक क्लाइंट हेडरों को वर्णानुक्रम में भेजते हैं, जो ब्राउज़रों के व्यवहार से भिन्न है। कस्टम हेडर क्रम का समर्थन करने वाली पुस्तकालयों का उपयोग करें।

सलाह: वास्तविक ब्राउज़र के हेडरों की सटीक कॉपी प्राप्त करने के लिए ब्राउज़र के DevTools का उपयोग करें (Network tab → अनुरोध पर दाएं क्लिक करें → Copy → Copy as cURL) और फिर उन्हें अपने कोड में अनुकूलित करें।

यूजर-एजेंट का गतिशील निर्माण

सभी अनुरोधों के लिए एक ही यूजर-एजेंट का उपयोग करने से पहचान का जोखिम बढ़ता है। प्रासंगिक यूजर-एजेंट का एक पूल बनाएं और उन्हें घुमाएं। 

import random

# प्रासंगिक यूजर-एजेंट का पूल (दिसंबर 2024)
USER_AGENTS = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15',
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
]

def get_random_headers():
    ua = random.choice(USER_AGENTS)
    
    # चयनित UA के अनुसार अन्य हेडरों को अनुकूलित करना
    if 'Chrome' in ua:
        return {
            'User-Agent': ua,
            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
            # ... अन्य Chrome हेडर
        }
    elif 'Firefox' in ua:
        return {
            'User-Agent': ua,
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            # ... Firefox हेडर
        }
    # ... अन्य ब्राउज़रों के लिए प्रोसेसिंग

हेडलेस ब्राउज़रों का उपयोग

जब Cloudflare JavaScript चुनौती या उन्नत पहचान का उपयोग करता है, तो बाईपास का एकमात्र विश्वसनीय तरीका वास्तविक ब्राउज़र है। हेडलेस ब्राउज़र स्वचालित रूप से JavaScript, कुकीज़ को संभालते हैं और पूरी तरह से प्रामाणिक फिंगरप्रिंट बनाते हैं।

एंटी-डिटेक्ट पैच के साथ Playwright

Playwright - Selenium का एक आधुनिक विकल्प है जिसमें बेहतर प्रदर्शन है। हालाँकि, मानक Playwright को navigator.webdriver और अन्य संकेतों के माध्यम से आसानी से पहचाना जा सकता है। छिपाने के लिए playwright-stealth का उपयोग करें। 

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

def bypass_cloudflare(url, proxy):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=True,
            proxy={
                "server": f"http://{proxy['host']}:{proxy['port']}",
                "username": proxy['username'],
                "password": proxy['password']
            },
            args=[
                '--disable-blink-features=AutomationControlled',
                '--disable-dev-shm-usage',
                '--no-sandbox'
            ]
        )
        
        context = browser.new_context(
            viewport={'width': 1920, 'height': 1080},
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            locale='en-US',
            timezone_id='America/New_York'
        )
        
        page = context.new_page()
        stealth_sync(page)  # एंटी-डिटेक्ट पैच लागू करना
        
        # पृष्ठ पर जाना
        page.goto(url, wait_until='networkidle', timeout=30000)
        
        # Cloudflare चुनौती पार करने की प्रतीक्षा करना (आमतौर पर 5-10 सेकंड)
        page.wait_for_timeout(8000)
        
        # सफल बाईपास की जांच करना
        if 'Just a moment' in page.content():
            print('Cloudflare चुनौती पार नहीं हुई')
            return None
        
        # आगे के उपयोग के लिए कुकीज़ निकालना
        cookies = context.cookies()
        html = page.content()
        
        browser.close()
        return {'html': html, 'cookies': cookies}

# उपयोग
proxy_config = {
    'host': 'proxy.example.com',
    'port': 8080,
    'username': 'user',
    'password': 'pass'
}

result = bypass_cloudflare('https://example.com', proxy_config)

Puppeteer Extra के साथ प्लगइन्स

Node.js पारिस्थितिकी तंत्र के लिए, सबसे अच्छा समाधान puppeteer-extra है जिसमें puppeteer-extra-plugin-stealth प्लगइन है। यह प्लगइन 30 से अधिक विभिन्न स्वचालन छिपाने की तकनीकों को लागू करता है। 

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

puppeteer.use(StealthPlugin());

async function bypassCloudflare(url, proxyUrl) {
    const browser = await puppeteer.launch({
        headless: 'new',
        args: [
            `--proxy-server=${proxyUrl}`,
            '--disable-blink-features=AutomationControlled',
            '--window-size=1920,1080'
        ]
    });
    
    const page = await browser.newPage();
    
    // व्यूपोर्ट और यूजर-एजेंट सेट करना
    await page.setViewport({ width: 1920, height: 1080 });
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
    
    // navigator.webdriver को ओवरराइड करना
    await page.evaluateOnNewDocument(() => {
        delete Object.getPrototypeOf(navigator).webdriver;
    });
    
    // पृष्ठ पर जाना
    await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
    
    // चुनौती पार करने की प्रतीक्षा करना
    await page.waitForTimeout(8000);
    
    // सामग्री और कुकीज़ प्राप्त करना
    const content = await page.content();
    const cookies = await page.cookies();
    
    await browser.close();
    
    return { content, cookies };
}

// उपयोग का उदाहरण
bypassCloudflare('https://example.com', 'http://user:pass@proxy.example.com:8080')
    .then(result => console.log('सफलता'))
    .catch(err => console.error(err));

प्रदर्शन: हेडलेस ब्राउज़र काफी अधिक संसाधनों का उपभोग करते हैं (200-500 MB RAM प्रति उदाहरण)। उच्च-भार वाले कार्यों के लिए, केवल कुकीज़ प्राप्त करने के लिए उनका उपयोग करें, फिर HTTP क्लाइंट पर स्विच करें जिनके पास ये कुकीज़ हैं।

Cloudflare को बाईपास करने के लिए प्रॉक्सी के प्रकार का चयन

प्रॉक्सी का प्रकार बाईपास की सफलता पर महत्वपूर्ण प्रभाव डालता है। Cloudflare डेटा सेंटर के IP पते का डेटाबेस रखता है और उन पर अधिक सख्त जांच नियम लागू करता है।

प्रॉक्सी का प्रकार बाईपास की संभावना गति लागत सिफारिश
डेटा सेंटर 30-40% उच्च कम केवल हेडलेस ब्राउज़रों के साथ
रिहायशी 85-95% मध्यम उच्च सर्वश्रेष्ठ विकल्प
मोबाइल 90-98% मध्यम बहुत उच्च महत्वपूर्ण कार्यों के लिए
ISP (स्थिर रिहायशी) 80-90% उच्च मध्यम कीमत और गुणवत्ता का संतुलन

रिहायशी प्रॉक्सी अधिक प्रभावी क्यों हैं

रिहायशी प्रॉक्सी वास्तविक उपकरणों (घरेलू राउटर, स्मार्टफोन) के IP पतों का उपयोग करते हैं। Cloudflare इन IP को बड़े पैमाने पर ब्लॉक नहीं कर सकता, क्योंकि इससे सामान्य उपयोगकर्ता प्रभावित होंगे। आंकड़े बताते हैं कि रिहायशी IP को डेटा सेंटर की तुलना में 15-20 गुना कम कैप्चा मिलते हैं।

रिहायशी प्रॉक्सी के साथ काम करते समय, भू-स्थान महत्वपूर्ण है। यदि लक्षित साइट अमेरिका पर केंद्रित है, तो एशिया से प्रॉक्सी का उपयोग संदिग्धता बढ़ा देगा। व्यापक भूगोल और शहरों के लिए लक्ष्यीकरण की क्षमता वाले प्रदाताओं का चयन करें।

अधिकतम विश्वसनीयता के लिए मोबाइल प्रॉक्सी

मोबाइल प्रॉक्सी मोबाइल ऑपरेटरों (4G/5G) के IP पतों का उपयोग करते हैं। मोबाइल नेटवर्क की विशेषता यह है कि यह उड़ान मोड के माध्यम से IP को गतिशील रूप से बदलता है, जिससे लगभग अनंत संख्या में स्वच्छ IP पते मिलते हैं। मोबाइल IP के ब्लॉक होने की संभावना लगभग शून्य है। 

# API के माध्यम से मोबाइल IP का रोटेशन
import requests
import time

def rotate_mobile_ip(proxy_api_url):
    """मोबाइल प्रॉक्सी का IP बदलना"""
    response = requests.get(f"{proxy_api_url}/rotate")
    if response.status_code == 200:
        print("IP सफलतापूर्वक बदल गया")
        time.sleep(5)  # परिवर्तन लागू होने की प्रतीक्षा
        return True
    return False

# मोबाइल प्रॉक्सी के साथ उपयोग
mobile_proxy = "http://user:pass@mobile.proxy.com:8080"

for i in range(10):
    # अनुरोध करना
    response = requests.get(
        'https://example.com',
        proxies={'http': mobile_proxy, 'https': mobile_proxy}
    )
    
    # प्रत्येक अनुरोध के बाद IP का रोटेशन
    rotate_mobile_ip('https://api.proxy.com/mobile')

कुकीज़ और सत्रों का प्रबंधन

Cloudflare चुनौती को सफलतापूर्वक पार करने के बाद, सर्वर कुकीज़ (cf_clearance, __cfduid और अन्य) स्थापित करता है, जो ग्राहक की वैधता की पुष्टि करते हैं। इन कुकीज़ का सही प्रबंधन दोबारा जांच से बचने में मदद करता है।

cf_clearance को निकालना और पुन: उपयोग करना

कुकी cf_clearance आमतौर पर 30-60 मिनट के लिए वैध होती है। हेडलेस ब्राउज़र के माध्यम से प्राप्त करने के बाद, इसे सामान्य HTTP अनुरोधों में उपयोग किया जा सकता है। 

import requests
import pickle
from datetime import datetime, timedelta

class CloudflareCookieManager:
    def __init__(self, cookie_file='cf_cookies.pkl'):
        self.cookie_file = cookie_file
        self.cookies = self.load_cookies()
    
    def load_cookies(self):
        """सहेजे गए कुकीज़ लोड करना"""
        try:
            with open(self.cookie_file, 'rb') as f:
                data = pickle.load(f)
                # समाप्ति समय की जांच
                if data['expires'] > datetime.now():
                    return data['cookies']
        except FileNotFoundError:
            pass
        return None
    
    def save_cookies(self, cookies, ttl_minutes=30):
        """TTL के साथ कुकीज़ सहेजना"""
        data = {
            'cookies': cookies,
            'expires': datetime.now() + timedelta(minutes=ttl_minutes)
        }
        with open(self.cookie_file, 'wb') as f:
            pickle.dump(data, f)
    
    def get_cf_clearance(self, url, proxy):
        """ब्राउज़र के माध्यम से cf_clearance प्राप्त करना"""
        if self.cookies:
            return self.cookies
        
        # यहाँ ब्राउज़र चलाने का कोड (पिछले अनुभाग से)
        # ...
        browser_cookies = bypass_cloudflare(url, proxy)['cookies']
        
        # requests प्रारूप में परिवर्तित करना
        cookies_dict = {c['name']: c['value'] for c in browser_cookies}
        self.save_cookies(cookies_dict)
        self.cookies = cookies_dict
        
        return cookies_dict
    
    def make_request(self, url, proxy):
        """स्वचालित कुकी प्रबंधन के साथ अनुरोध"""
        cookies = self.get_cf_clearance(url, proxy)
        
        response = requests.get(
            url,
            cookies=cookies,
            proxies={'http': proxy, 'https': proxy},
            headers=get_random_headers()
        )
        
        # यदि फिर से चुनौती प्राप्त होती है - कुकीज़ को अपडेट करें
        if response.status_code == 403 or 'cf-browser-verification' in response.text:
            print("कुकीज़ पुरानी हो गई हैं, नए प्राप्त कर रहे हैं...")
            self.cookies = None
            return self.make_request(url, proxy)
        
        return response

# उपयोग
manager = CloudflareCookieManager()
response = manager.make_request(
    'https://example.com/api/data',
    'http://user:pass@proxy.example.com:8080'
)

IP पते से कुकीज़ को बांधना

Cloudflare cf_clearance को उस IP पते से बांधता है, जिससे चुनौती पार की गई थी। इस कुकी का उपयोग किसी अन्य IP के साथ करने से ब्लॉक हो जाएगा। घुमाने वाली प्रॉक्सी के साथ काम करते समय, प्रत्येक IP के लिए अलग कुकीज़ सेट रखना आवश्यक है। 

import hashlib

class IPBoundCookieManager:
    def __init__(self):
        self.cookies_by_ip = {}
    
    def get_ip_hash(self, proxy_url):
        """प्रॉक्सी की पहचान के लिए हैश बनाना"""
        return hashlib.md5(proxy_url.encode()).hexdigest()
    
    def get_cookies_for_proxy(self, proxy_url, target_url):
        """विशिष्ट प्रॉक्सी के लिए कुकीज़ प्राप्त करना"""
        ip_hash = self.get_ip_hash(proxy_url)
        
        if ip_hash in self.cookies_by_ip:
            cookies_data = self.cookies_by_ip[ip_hash]
            if cookies_data['expires'] > datetime.now():
                return cookies_data['cookies']
        
        # ब्राउज़र के माध्यम से नए कुकीज़ प्राप्त करना
        new_cookies = self.fetch_cookies_with_browser(target_url, proxy_url)
        
        self.cookies_by_ip[ip_hash] = {
            'cookies': new_cookies,
            'expires': datetime.now() + timedelta(minutes=30)
        }
        
        return new_cookies

प्रॉक्सी का रोटेशन और अनुरोधों की आवृत्ति का नियंत्रण

सही तकनीकी स्टैक के साथ भी, एक IP से बहुत अधिक अनुरोधों की आवृत्ति दर सीमित करने का ट्रिगर बनाती है। Cloudflare ट्रैफ़िक पैटर्न का विश्लेषण करता है और असामान्य गतिविधि का पता लगाता है।

प्रॉक्सी रोटेशन की रणनीतियाँ

रोटेशन के लिए तीन मुख्य दृष्टिकोण हैं: राउंड-रॉबिन (क्रमिक), रैंडम (यादृच्छिक) और स्टिकी सत्र (सत्र के लिए बंधन)। Cloudflare को बाईपास करने के लिए IP पर अनुरोधों की सीमा के साथ स्टिकी सत्र की रणनीति सबसे उपयुक्त है। 

import time
import random
from collections import defaultdict
from datetime import datetime, timedelta

class SmartProxyRotator:
    def __init__(self, proxy_list, max_requests_per_ip=20, cooldown_minutes=10):
        self.proxy_list = proxy_list
        self.max_requests_per_ip = max_requests_per_ip
        self.cooldown_minutes = cooldown_minutes
        
        # उपयोग की गणना
        self.usage_count = defaultdict(int)
        self.last_used = {}
        self.cooldown_until = {}
    
    def get_proxy(self):
        """अगला उपलब्ध प्रॉक्सी प्राप्त करना"""
        available_proxies = []
        
        for proxy in self.proxy_list:
            # कूलडाउन की जांच
            if proxy in self.cooldown_until:
                if datetime.now() < self.cooldown_until[proxy]:
                    continue
                else:
                    # कूलडाउन के बाद गणना को रीसेट करना
                    self.usage_count[proxy] = 0
                    del self.cooldown_until[proxy]
            
            # अनुरोधों की सीमा की जांच
            if self.usage_count[proxy] < self.max_requests_per_ip:
                available_proxies.append(proxy)
        
        if not available_proxies:
            # यदि सभी प्रॉक्सी कूलडाउन में हैं - प्रतीक्षा करें
            wait_time = min(
                (self.cooldown_until[p] - datetime.now()).total_seconds()
                for p in self.cooldown_until
            )
            print(f"सभी प्रॉक्सी कूलडाउन में हैं। {wait_time:.0f} सेकंड प्रतीक्षा कर रहे हैं...")
            time.sleep(wait_time + 1)
            return self.get_proxy()
        
        # सबसे कम उपयोग वाले प्रॉक्सी का चयन करें
        proxy = min(available_proxies, key=lambda p: self.usage_count[p])
        
        self.usage_count[proxy] += 1
        self.last_used[proxy] = datetime.now()
        
        # सीमा पर पहुँचने पर कूलडाउन सेट करना
        if self.usage_count[proxy] >= self.max_requests_per_ip:
            self.cooldown_until[proxy] = datetime.now() + timedelta(
                minutes=self.cooldown_minutes
            )
            print(f"प्रॉक्सी {proxy} ने सीमा तक पहुँच गया। कूलडाउन {self.cooldown_minutes} मिनट।")
        
        return proxy
    
    def add_delay(self):
        """अनुरोधों के बीच यादृच्छिक देरी (मनुष्य की नकल)"""
        delay = random.uniform(2, 5)  # 2-5 सेकंड
        time.sleep(delay)

# उपयोग
proxy_pool = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
    # ... स्थिरता के लिए 50-100 प्रॉक्सी तक
]

rotator = SmartProxyRotator(
    proxy_pool,
    max_requests_per_ip=15,  # संवेदनशील मान
    cooldown_minutes=15
)

# अनुरोधों का निष्पादन
for i in range(1000):
    proxy = rotator.get_proxy()
    
    response = requests.get(
        'https://example.com/page',
        proxies={'http': proxy, 'https': proxy},
        headers=get_random_headers()
    )
    
    print(f"अनुरोध {i+1}: {response.status_code}")
    rotator.add_delay()

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

एक अधिक उन्नत दृष्टिकोण - सर्वर के उत्तरों के आधार पर अनुरोधों की आवृत्ति को गतिशील रूप से अनुकूलित करना। यदि 429 त्रुटियाँ या कैप्चा दिखाई देने लगते हैं, तो स्वचालित रूप से गति को कम करें। 

class AdaptiveRateLimiter:
    def __init__(self, initial_delay=3.0):
        self.delay = initial_delay
        self.min_delay = 1.0
        self.max_delay = 30.0
        self.success_streak = 0
        self.failure_streak = 0
    
    def on_success(self):
        """सफल अनुरोध - गति बढ़ा सकते हैं"""
        self.success_streak += 1
        self.failure_streak = 0
        
        if self.success_streak >= 10:
            # 10% की देरी कम करें
            self.delay = max(self.min_delay, self.delay * 0.9)
            self.success_streak = 0
    
    def on_failure(self, status_code):
        """त्रुटि - गति कम करें"""
        self.failure_streak += 1
        self.success_streak = 0
        
        if status_code == 429:  # दर सीमा
            # आक्रामक रूप से धीमा करना
            self.delay = min(self.max_delay, self.delay * 2.0)
        elif status_code == 403:  # संभावित ब्लॉक
            self.delay = min(self.max_delay, self.delay * 1.5)
        
        print(f"देरी बढ़ाकर {self.delay:.2f}s कर दी गई है")
    
    def wait(self):
        """अगले अनुरोध से पहले प्रतीक्षा करना"""
        # ±20% यादृच्छिकता जोड़ें
        actual_delay = self.delay * random.uniform(0.8, 1.2)
        time.sleep(actual_delay)

बाईपास के लिए तैयार उपकरण और पुस्तकालय

शून्य से अपना समाधान विकसित करना समय और विशेषज्ञता की आवश्यकता है। ऐसे तैयार उपकरण हैं जो Cloudflare के बाईपास प्रक्रिया को स्वचालित करते हैं।

cloudscraper (Python)

cloudscraper पुस्तकालय - requests पर एक ओवरले है, जो स्वचालित रूप से JavaScript चुनौतियों को हल करता है। यह बुनियादी सुरक्षा के साथ काम करता है, लेकिन उन्नत जांचों से निपटने में असमर्थ हो सकता है। 

import cloudscraper

# प्रॉक्सी के समर्थन के साथ स्क्रैपर बनाना
scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

# प्रॉक्सी सेट करना
proxies = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

# अनुरोध करना
response = scraper.get('https://example.com', proxies=proxies)

if response.status_code == 200:
    print("सफल बाईपास")
    print(response.text)
else:
    print(f"त्रुटि: {response.status_code}")

FlareSolverr (यूनिवर्सल)

FlareSolverr - एक प्रॉक्सी सर्वर है जो Cloudflare चुनौतियों को हल करने के लिए हेडलेस ब्राउज़र चलाता है। यह HTTP API के माध्यम से काम करता है और किसी भी प्रोग्रामिंग भाषा का समर्थन करता है। 

# FlareSolverr को Docker के माध्यम से चलाना
docker run -d \
  --name=flaresolverr \
  -p 8191:8191 \
  -e LOG_LEVEL=info \
  ghcr.io/flaresolverr/flaresolverr:latest

# Python से उपयोग
import requests

def solve_cloudflare(url, proxy=None):
    flaresolverr_url = "http://localhost:8191/v1"
    
    payload = {
        "cmd": "request.get",
        "url": url,
        "maxTimeout": 60000
    }
    
    if proxy:
        payload["proxy"] = {
            "url": proxy
        }
    
    response = requests.post(flaresolverr_url, json=payload)
    result = response.json()
    
    if result['status'] == 'ok':
        return {
            'html': result['solution']['response'],
            'cookies': result['solution']['cookies'],
            'user_agent': result['solution']['userAgent']
        }
    else:
        raise Exception(f"FlareSolverr त्रुटि: {result['message']}")

# उपयोग का उदाहरण
result = solve_cloudflare(
    'https://example.com',
    proxy='http://user:pass@proxy.example.com:8080'
)

print(result['html'])

undetected-chromedriver

Selenium ChromeDriver का एक पैच किया गया संस्करण है, जो स्वचालित रूप से कई एंटी-डिटेक्ट तकनीकों को लागू करता है। Playwright की तुलना में उपयोग में आसान, लेकिन कम लचीला है। 

import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def bypass_with_uc(url, proxy):
    options = uc.ChromeOptions()
    options.add_argument(f'--proxy-server={proxy}')
    options.add_argument('--disable-blink-features=AutomationControlled')
    
    driver = uc.Chrome(options=options, version_main=120)
    
    try:
        driver.get(url)
        
        # Cloudflare चुनौती के गायब होने की प्रतीक्षा करना
        WebDriverWait(driver, 20).until_not(
            EC.presence_of_element_located((By.ID, "cf-spinner-please-wait"))
        )
        
        # विश्वसनीयता के लिए अतिरिक्त प्रतीक्षा
        time.sleep(3)
        
        # परिणाम प्राप्त करना
        html = driver.page_source
        cookies = driver.get_cookies()
        
        return {'html': html, 'cookies': cookies}
    
    finally:
        driver.quit()

# उपयोग
result = bypass_with_uc(
    'https://example.com',
    'http://user:pass@proxy.example.com:8080'
)

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

निष्कर्ष

प्रॉक्सी के माध्यम से Cloudflare को बाईपास करना एक समग्र दृष्टिकोण की आवश्यकता है: सही TLS फिंगरप्रिंट, प्रामाणिक HTTP हेडर, गुणवत्ता वाली प्रॉक्सी और कुशल सत्र प्रबंधन। प्रमुख सिफारिशें:

  • डेटा सेंटर के बजाय रिहायशी या मोबाइल प्रॉक्सी का उपयोग करें
  • सही TLS फिंगरप्रिंट के साथ पुस्तकालयों का उपयोग करें (tls-client, curl-impersonate)
  • जटिल मामलों के लिए एंटी-डिटेक्ट पैच के साथ हेडलेस ब्राउज़रों का उपयोग करें
  • cf_clearance कुकीज़ को सहेजें और पुन: उपयोग करें
  • दर सीमित करने को ध्यान में रखते हुए प्रॉक्सी का रोटेशन करें (IP पर 15-20 अनुरोधों से अधिक नहीं)
  • अनुरोधों के बीच यादृच्छिक देरी जोड़ें (2-5 सेकंड)

Cloudflare की सुरक्षा लगातार विकसित हो रही है, इसलिए उपकरणों को नियमित रूप से अपडेट करना और रणनीतियों को अनुकूलित करना महत्वपूर्ण है। फिंगरप्रिंटिंग तकनीकों में परिवर्तनों की निगरानी करें और वर्तमान सुरक्षा संस्करणों पर समाधानों का परीक्षण करें।

स्थिरता के लिए, व्यापक IP पूल और स्वचालित रोटेशन के साथ पेशेवर प्रॉक्सी सेवाओं का उपयोग करने की सिफारिश की जाती है।

```