7 طرق مثبتة لتجاوز كشف Cloudflare عند العمل عبر البروكسي

يعالج Cloudflare أكثر من 20% من إجمالي حركة الويب ويستخدم نظام حماية متعدد الطبقات ضد الروبوتات. عند العمل عبر خوادم البروكسي، تزداد احتمالية الحصول على CAPTCHA أو حظر بشكل كبير. في هذا الدليل، سنستعرض الجوانب التقنية للكشف وطرق التجاوز العملية التي تعمل في عام 2024.

كيف يحدد Cloudflare البروكسي والروبوتات

يستخدم Cloudflare نظام تحليل شامل يتحقق من عشرات المعايير لكل طلب. فهم آليات الكشف هو الخطوة الأولى نحو تجاوز الحماية بنجاح.

الطرق الرئيسية للكشف

عند تحليل الطلب، يقوم Cloudflare بمطابقة بصمة TLS مع User-Agent المعلن. إذا كنت تشير إلى Chrome 120، ولكن معلمات TLS تتوافق مع Python requests - فهذا يعني كشف فوري للروبوت.

منذ عام 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

توجد لفافة tls-client لـ Python، التي تستخدم 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

قبل البدء في عملية التحليل، يُنصح بالتحقق من بصمة 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 الصحيحة، ستظهر الرؤوس غير الصحيحة كروبوت. يقوم 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 وغيرها من العملاء القياسيين بإرسال الرؤوس بترتيب أبجدي، مما يختلف عن سلوك المتصفحات. استخدم مكتبات تدعم ترتيب الرؤوس المخصص.

توليد User-Agent ديناميكي

استخدام نفس User-Agent لجميع الطلبات يزيد من خطر الكشف. أنشئ مجموعة من User-Agents الحالية وقم بتدويرها.

import random

# مجموعة من User-Agents الحالية (ديسمبر 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 مع تصحيحات anti-detect

Playwright هو بديل حديث لـ Selenium مع أداء أفضل. ومع ذلك، فإن Playwright القياسي يمكن اكتشافه بسهولة من خلال navigator.webdriver

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)  # تطبيق تصحيحات anti-detect
        
        # الانتقال إلى الصفحة
        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();
    
    // إعداد viewport و user-agent
    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));

اختيار نوع البروكسي لتجاوز Cloudflare

يؤثر نوع البروكسي بشكل حاسم على نجاح التجاوز. يحتفظ Cloudflare بقواعد بيانات لعناوين IP الخاصة بمراكز البيانات ويطبق عليها قواعد تحقق أكثر صرامة.

لماذا تكون البروكسي السكنية أكثر فعالية

البروكسي السكنية تستخدم عناوين IP لأجهزة حقيقية (موجهات منزلية، هواتف ذكية). لا يمكن لـ Cloudflare حظر هذه العناوين بشكل جماعي، حيث سيؤدي ذلك إلى حظر المستخدمين العاديين. تظهر الإحصائيات أن عناوين IP السكنية تحصل على CAPTCHA بمعدل 15-20 مرة أقل من مراكز البيانات.

عند العمل مع البروكسي السكنية، تعتبر الجغرافيا مهمة للغاية. إذا كان الموقع المستهدف موجهًا نحو الولايات المتحدة، فإن استخدام بروكسي من آسيا سيزيد من الشكوك. اختر مزودين لديهم جغرافيا واسعة وإمكانية الاستهداف حسب المدن.

البروكسي المحمولة لتحقيق أقصى موثوقية

البروكسي المحمولة تستخدم عناوين IP لمشغلي الهواتف المحمولة (4G/5G). تتميز الشبكات المحمولة بتغيير ديناميكي لعنوان IP عبر وضع الطيران، مما يوفر عددًا غير محدود تقريبًا من عناوين IP النظيفة. احتمالية حظر عنوان IP المحمول قريبة من الصفر.

# مثال لتدوير IP المحمول عبر API
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 بتحليل أنماط الحركة ويكتشف الأنشطة غير الطبيعية.

استراتيجيات تدوير البروكسي

هناك ثلاث طرق رئيسية للتدوير: round-robin (تتابعي)، random (عشوائي) وsticky sessions (ربط الجلسة). لاستراتيجية تجاوز Cloudflare، فإن استراتيجية sticky sessions مع تحديد الطلبات على 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 أو CAPTCHA، نقوم تلقائيًا بتقليل السرعة.

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 مع دعم البروكسي
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، تقوم تلقائيًا بتطبيق العديد من تقنيات anti-detect. أسهل في الاستخدام من 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'
)

الخاتمة

يتطلب تجاوز Cloudflare عند العمل عبر البروكسي نهجًا شاملاً: بصمة TLS الصحيحة، رؤوس HTTP أصيلة، بروكسي عالية الجودة وإدارة فعالة للجلسات. التوصيات الرئيسية:

• استخدم البروكسي السكنية أو البروكسي المحمولة بدلاً من مراكز البيانات
• طبق المكتبات مع بصمة TLS الصحيحة (tls-client، curl-impersonate)
• للحالات المعقدة، استخدم المتصفحات بدون واجهة مستخدم مع تصحيحات anti-detect
• احفظ وأعد استخدام كوكيز cf_clearance
• قم بتدوير البروكسي مع مراعاة قيود المعدل (لا تزيد عن 15-20 طلبًا لكل IP)
• أضف تأخيرات عشوائية بين الطلبات (2-5 ثواني)

تتطور حماية Cloudflare باستمرار، لذا من المهم تحديث الأدوات بانتظام وتكييف الاستراتيجيات. راقب التغييرات في تقنيات البصمة واختبر الحلول على أحدث إصدارات الحماية.

للحصول على أداء مستقر، يُنصح باستخدام خدمات بروكسي احترافية مع مجموعة واسعة من عناوين IP وتدوير تلقائي.