Proxy üzerinden Cloudflare tespitini aşmanın 7 kanıtlanmış yolu

Cloudflare, tüm web trafiğinin %20'sinden fazlasını işliyor ve botlara karşı çok katmanlı bir koruma sistemi kullanıyor. Proxy sunucuları üzerinden çalışırken, CAPTCHA veya engellenme olasılığı katlanarak artıyor. Bu kılavuzda, 2024 yılında işe yarayan tespit teknikleri ve pratik aşma yöntemlerini inceleyeceğiz.

Cloudflare proxy ve botları nasıl tespit ediyor

Cloudflare, her isteğin onlarca parametresini kontrol eden kapsamlı bir analiz sistemi kullanıyor. Tespit mekanizmalarını anlamak, korumayı başarılı bir şekilde aşmanın ilk adımıdır.

Temel tespit yöntemleri

Cloudflare, isteği analiz ederken TLS parmak izini belirtilen User-Agent ile karşılaştırır. Eğer Chrome 120 belirtiyorsanız ama TLS parametreleri Python requests ile eşleşiyorsa, bu anında bir bot tespiti demektir.

2023 yılından itibaren Cloudflare, davranışsal kalıpları analiz etmek için makine öğrenimini aktif olarak kullanıyor. Sistem, yalnızca teknik parametreleri değil, aynı zamanda istekler arasındaki zaman aralıklarını, kullanıcı eylemlerinin sırasını, fare hareketlerini ve sayfa kaydırmalarını da izliyor.

TLS parmak izinin maskelemesi

TLS parmak izi, bot tespitinin en etkili yöntemidir. Standart HTTP istemcileri (requests, curl, axios), gerçek bir tarayıcı ile karıştırılamayacak bir parmak izi oluşturur. Çözüm, tarayıcıların TLS davranışını taklit eden özel kütüphanelerin kullanılmasıdır.

curl-impersonate kullanımı

curl-impersonate kütüphanesi, popüler tarayıcıların TLS ve HTTP/2 parmak izlerini tam olarak kopyalayan modifiye edilmiş bir curl versiyonudur. Chrome, Firefox, Safari ve Edge'i destekler.

# curl-impersonate kurulumu
git clone https://github.com/lwthiker/curl-impersonate
cd curl-impersonate
make chrome-build

# Chrome 120 taklidi ile kullanımı
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 kütüphanesi

Python için, arka planda curl-impersonate kullanan ve requests'e benzer bir arayüz sunan tls-client adında bir sarmalayıcı bulunmaktadır.

import tls_client

# Chrome 120 parmak izi ile oturum oluşturma
session = tls_client.Session(
    client_identifier="chrome_120",
    random_tls_extension_order=True
)

# Proxy ayarlama
proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080'
}

# İstek yapma
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 parmak izinin kontrolü

Parsinge başlamadan önce TLS parmak izinizi kontrol etmeniz önerilir. Analiz için tls.peet.ws veya ja3er.com hizmetlerini kullanın.

# Parmak izinin kontrolü
response = session.get('https://tls.peet.ws/api/all')
print(response.json()['tls']['ja3'])

# Gerçek Chrome parmak izi ile karşılaştırın:
# https://kawayiyi.com/tls-fingerprint-database/

HTTP başlıklarının doğru ayarlanması

Doğru TLS parmak izine sahip olsanız bile, yanlış HTTP başlıkları bir botu ifşa eder. Cloudflare, yalnızca başlıkların varlığını değil, aynı zamanda sırasını, değer formatını ve mantıksal tutarlılığını da analiz eder.

Chrome için zorunlu başlıklar

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-* başlıkları Chrome 89'da ortaya çıkmış ve Client Hints API'nin bir parçasıdır. Modern bir User-Agent kullanırken bunların yokluğu, açık bir bot işareti olarak kabul edilir.

Başlık sırası önemlidir

HTTP/2'de başlık sırası her tarayıcı için sabittir. Python requests ve diğer standart istemciler, başlıkları alfabetik sırayla gönderir, bu da tarayıcıların davranışından farklıdır. Özel başlık sırası desteği olan kütüphaneler kullanın.

User-Agent'in dinamik olarak üretilmesi

Tüm istekler için aynı User-Agent kullanmak, tespit riskini artırır. Güncel User-Agent'lerin bir havuzunu oluşturun ve bunları döndürün.

import random

# Güncel User-Agent havuzu (Aralık 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)
    
    # Seçilen UA'ya göre diğer başlıkları uyarlama
    if 'Chrome' in ua:
        return {
            'User-Agent': ua,
            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
            # ... diğer Chrome başlıkları
        }
    elif 'Firefox' in ua:
        return {
            'User-Agent': ua,
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            # ... Firefox başlıkları
        }
    # ... diğer tarayıcılar için işleme

Headless tarayıcıların kullanımı

Cloudflare JavaScript zorluğu veya gelişmiş tespit kullandığında, güvenilir bir aşma yöntemi gerçek bir tarayıcıdır. Headless tarayıcılar, JavaScript'i, çerezleri otomatik olarak işler ve tamamen otantik bir parmak izi oluşturur.

Anti-detect yamanları ile Playwright

Playwright, Selenium'a modern bir alternatif olup daha iyi performans sunar. Ancak, standart Playwright, navigator.webdriver ve diğer işaretler aracılığıyla kolayca tespit edilebilir. Maskeleme için playwright-stealth kullanın.

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 yamalarının uygulanması
        
        # Sayfaya git
        page.goto(url, wait_until='networkidle', timeout=30000)
        
        # Cloudflare zorluğunu geçmek için bekleme (genellikle 5-10 saniye)
        page.wait_for_timeout(8000)
        
        # Başarılı bir aşma kontrolü
        if 'Just a moment' in page.content():
            print('Cloudflare zorluğu geçilemedi')
            return None
        
        # Gelecek kullanım için çerezleri çıkarma
        cookies = context.cookies()
        html = page.content()
        
        browser.close()
        return {'html': html, 'cookies': cookies}

# Kullanım
proxy_config = {
    'host': 'proxy.example.com',
    'port': 8080,
    'username': 'user',
    'password': 'pass'
}

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

Eklentiler ile Puppeteer Extra

Node.js ekosistemi için en iyi çözüm, puppeteer-extra ve puppeteer-extra-plugin-stealth eklentisidir. Bu eklenti, 30'dan fazla farklı otomasyon maskeleme tekniği uygular.

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();
    
    // Görünüm ve kullanıcı ajanı ayarlama
    await page.setViewport({ width: 1920, height: 1080 });
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
    
    // navigator.webdriver'ı geçersiz kılma
    await page.evaluateOnNewDocument(() => {
        delete Object.getPrototypeOf(navigator).webdriver;
    });
    
    // Sayfaya git
    await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
    
    // Zorluğun geçmesini bekleme
    await page.waitForTimeout(8000);
    
    // İçeriği ve çerezleri alma
    const content = await page.content();
    const cookies = await page.cookies();
    
    await browser.close();
    
    return { content, cookies };
}

// Örnek kullanım
bypassCloudflare('https://example.com', 'http://user:pass@proxy.example.com:8080')
    .then(result => console.log('Başarılı'))
    .catch(err => console.error(err));

Cloudflare'ı aşmak için proxy türünün seçimi

Proxy türü, aşmanın başarısını kritik şekilde etkiler. Cloudflare, veri merkezi IP adresleri için veri tabanları tutar ve bunlara daha sıkı kontrol kuralları uygular.

Neden konut proxy'leri daha etkilidir

Konut proxy'leri, gerçek cihazların (ev yönlendiricileri, akıllı telefonlar) IP adreslerini kullanır. Cloudflare, bu tür IP'leri topluca engelleyemez, çünkü bu, normal kullanıcıları da engeller. İstatistikler, konut IP'lerinin, veri merkezlerine göre CAPTCHA alma oranının 15-20 kat daha düşük olduğunu göstermektedir.

Konut proxy'leri ile çalışırken, coğrafi konum kritik öneme sahiptir. Hedef site ABD'ye odaklanıyorsa, Asya'dan proxy kullanmak şüphe uyandırır. Geniş bir coğrafyaya sahip ve şehir bazında hedefleme imkanı sunan sağlayıcıları tercih edin.

Maksimum güvenilirlik için mobil proxy'ler

Mobil proxy'ler, mobil operatörlerin (4G/5G) IP adreslerini kullanır. Mobil ağların özelliği, uçak moduna geçerek IP'nin dinamik olarak değiştirilmesidir; bu da neredeyse sınırsız sayıda temiz IP adresi sağlar. Mobil IP'nin engellenme olasılığı neredeyse sıfıra yakındır.

# API üzerinden mobil IP döndürme örneği
import requests
import time

def rotate_mobile_ip(proxy_api_url):
    """Mobil proxy IP'sini değiştirme"""
    response = requests.get(f"{proxy_api_url}/rotate")
    if response.status_code == 200:
        print("IP başarıyla değiştirildi")
        time.sleep(5)  # Değişikliklerin uygulanmasını bekleme
        return True
    return False

# Mobil proxy ile kullanım
mobile_proxy = "http://user:pass@mobile.proxy.com:8080"

for i in range(10):
    # İstek yapma
    response = requests.get(
        'https://example.com',
        proxies={'http': mobile_proxy, 'https': mobile_proxy}
    )
    
    # Her istektan sonra IP döndürme
    rotate_mobile_ip('https://api.proxy.com/mobile')

Çerezler ve oturumların yönetimi

Cloudflare zorluğunu başarıyla geçtikten sonra, sunucu çerezler (cf_clearance, __cfduid ve diğerleri) ayarlar; bu çerezler, istemcinin meşruluğunu doğrular. Bu çerezlerin doğru yönetimi, tekrar kontrol edilmesini önler.

cf_clearance'ın çıkarılması ve yeniden kullanılması

cf_clearance çerezi genellikle 30-60 dakika geçerlidir. Headless tarayıcı aracılığıyla alındıktan sonra, normal HTTP isteklerinde kullanılabilir.

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):
        """Kaydedilen çerezleri yükleme"""
        try:
            with open(self.cookie_file, 'rb') as f:
                data = pickle.load(f)
                # Süre kontrolü
                if data['expires'] > datetime.now():
                    return data['cookies']
        except FileNotFoundError:
            pass
        return None
    
    def save_cookies(self, cookies, ttl_minutes=30):
        """TTL ile çerezleri kaydetme"""
        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):
        """Tarayıcı aracılığıyla cf_clearance alma"""
        if self.cookies:
            return self.cookies
        
        # Burada tarayıcıyı başlatma kodu (önceki bölümden)
        # ...
        browser_cookies = bypass_cloudflare(url, proxy)['cookies']
        
        # requests formatına dönüştürme
        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):
        """Otomatik çerez yönetimi ile istek yapma"""
        cookies = self.get_cf_clearance(url, proxy)
        
        response = requests.get(
            url,
            cookies=cookies,
            proxies={'http': proxy, 'https': proxy},
            headers=get_random_headers()
        )
        
        # Eğer tekrar zorluk alırsak — çerezleri güncelle
        if response.status_code == 403 or 'cf-browser-verification' in response.text:
            print("Çerezler süresi dolmuş, yenilerini alıyoruz...")
            self.cookies = None
            return self.make_request(url, proxy)
        
        return response

# Kullanım
manager = CloudflareCookieManager()
response = manager.make_request(
    'https://example.com/api/data',
    'http://user:pass@proxy.example.com:8080'
)

Çerezlerin IP adresine bağlanması

Cloudflare, cf_clearance'ı zorluğun geçtiği IP adresine bağlar. Bu çerezi başka bir IP ile kullanmak engellemeye yol açar. Döngüsel proxy'lerle çalışırken, her IP için ayrı bir çerez seti saklamak gerekir.

import hashlib

class IPBoundCookieManager:
    def __init__(self):
        self.cookies_by_ip = {}
    
    def get_ip_hash(self, proxy_url):
        """Proxy'yi tanımlamak için hash oluşturma"""
        return hashlib.md5(proxy_url.encode()).hexdigest()
    
    def get_cookies_for_proxy(self, proxy_url, target_url):
        """Belirli bir proxy için çerez alma"""
        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']
        
        # Tarayıcı aracılığıyla yeni çerezler alma
        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

Proxy döngüsü ve istek sıklığı kontrolü

Doğru teknik yığın ile bile, bir IP'den çok yüksek istek sıklığı, rate limiting'i tetikler. Cloudflare, trafik kalıplarını analiz eder ve anormal etkinlikleri tespit eder.

Proxy döndürme stratejileri

Üç temel döndürme yaklaşımı vardır: round-robin (sıralı), random (rastgele) ve sticky sessions (oturum bağlama). Cloudflare'ı aşmak için, IP başına istekleri sınırlayarak sticky sessions stratejisi en uygunudur.

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
        
        # Kullanım sayacı
        self.usage_count = defaultdict(int)
        self.last_used = {}
        self.cooldown_until = {}
    
    def get_proxy(self):
        """Bir sonraki mevcut proxy'yi alma"""
        available_proxies = []
        
        for proxy in self.proxy_list:
            # Soğuma kontrolü
            if proxy in self.cooldown_until:
                if datetime.now() < self.cooldown_until[proxy]:
                    continue
                else:
                    # Soğuma süresi dolduğunda sayacı sıfırlama
                    self.usage_count[proxy] = 0
                    del self.cooldown_until[proxy]
            
            # İstek limiti kontrolü
            if self.usage_count[proxy] < self.max_requests_per_ip:
                available_proxies.append(proxy)
        
        if not available_proxies:
            # Tüm proxy'ler soğuma süresindeyse — bekleyin
            wait_time = min(
                (self.cooldown_until[p] - datetime.now()).total_seconds()
                for p in self.cooldown_until
            )
            print(f"Tüm proxy'ler soğuma süresinde. {wait_time:.0f} saniye bekleniyor...")
            time.sleep(wait_time + 1)
            return self.get_proxy()
        
        # En az kullanılan proxy'yi seçme
        proxy = min(available_proxies, key=lambda p: self.usage_count[p])
        
        self.usage_count[proxy] += 1
        self.last_used[proxy] = datetime.now()
        
        # Limite ulaşıldığında soğuma süresi ayarlama
        if self.usage_count[proxy] >= self.max_requests_per_ip:
            self.cooldown_until[proxy] = datetime.now() + timedelta(
                minutes=self.cooldown_minutes
            )
            print(f"{proxy} proxy'si limite ulaştı. {self.cooldown_minutes} dakikalık soğuma süresi.")
        
        return proxy
    
    def add_delay(self):
        """İstekler arasında rastgele gecikme (insan taklidi)"""
        delay = random.uniform(2, 5)  # 2-5 saniye
        time.sleep(delay)

# Kullanım
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 proxy için stabil çalışma
]

rotator = SmartProxyRotator(
    proxy_pool,
    max_requests_per_ip=15,  # Muhafazakar değer
    cooldown_minutes=15
)

# İstekleri gerçekleştirme
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"İstek {i+1}: {response.status_code}")
    rotator.add_delay()

Adaptif rate limiting

Daha gelişmiş bir yaklaşım, sunucu yanıtlarına dayalı olarak istek sıklığını dinamik olarak ayarlamaktır. Eğer 429 hataları veya CAPTCHA'lar ortaya çıkmaya başlarsa, otomatik olarak hızı azaltın.

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):
        """Başarılı istek — hızlanabiliriz"""
        self.success_streak += 1
        self.failure_streak = 0
        
        if self.success_streak >= 10:
            # Gecikmeyi %10 azalt
            self.delay = max(self.min_delay, self.delay * 0.9)
            self.success_streak = 0
    
    def on_failure(self, status_code):
        """Hata — yavaşlayalım"""
        self.failure_streak += 1
        self.success_streak = 0
        
        if status_code == 429:  # Rate limit
            # Agresif yavaşlama
            self.delay = min(self.max_delay, self.delay * 2.0)
        elif status_code == 403:  # Olası engelleme
            self.delay = min(self.max_delay, self.delay * 1.5)
        
        print(f"Gecikme {self.delay:.2f}s'ye çıkarıldı")
    
    def wait(self):
        """Bir sonraki isteği bekleme"""
        # Rastgelelik ekleyin ±%20
        actual_delay = self.delay * random.uniform(0.8, 1.2)
        time.sleep(actual_delay)

Aşma için hazır araçlar ve kütüphaneler

Sıfırdan kendi çözümünüzü geliştirmek zaman ve uzmanlık gerektirir. Cloudflare'ı aşmayı otomatikleştiren hazır araçlar mevcuttur.

cloudscraper (Python)

cloudscraper kütüphanesi, JavaScript zorluklarını otomatik olarak çözen requests üzerine bir üst yapıdır. Temel korumalarla çalışır, ancak gelişmiş kontrollerle başa çıkamayabilir.

import cloudscraper

# Proxy desteği ile scraper oluşturma
scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

# Proxy ayarlama
proxies = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

# İstek yapma
response = scraper.get('https://example.com', proxies=proxies)

if response.status_code == 200:
    print("Başarılı aşma")
    print(response.text)
else:
    print(f"Hata: {response.status_code}")

FlareSolverr (evrensel)

FlareSolverr, Cloudflare zorluklarını çözmek için headless tarayıcıyı çalıştıran bir proxy sunucusudur. HTTP API aracılığıyla çalışır ve herhangi bir programlama dilini destekler.

# FlareSolverr'ı Docker üzerinden çalıştırma
docker run -d \
  --name=flaresolverr \
  -p 8191:8191 \
  -e LOG_LEVEL=info \
  ghcr.io/flaresolverr/flaresolverr:latest

# Python'dan kullanım
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 hatası: {result['message']}")

# Örnek kullanım
result = solve_cloudflare(
    'https://example.com',
    proxy='http://user:pass@proxy.example.com:8080'
)

print(result['html'])

undetected-chromedriver

Selenium ChromeDriver'ın yamalanmış bir versiyonu olup, otomatik olarak birçok anti-detect tekniği uygular. Playwright'tan daha kolay kullanılır, ancak daha az esneklik sunar.

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 zorluğunun kaybolmasını bekleme
        WebDriverWait(driver, 20).until_not(
            EC.presence_of_element_located((By.ID, "cf-spinner-please-wait"))
        )
        
        # Güvenilirlik için ek bekleme
        time.sleep(3)
        
        # Sonucu alma
        html = driver.page_source
        cookies = driver.get_cookies()
        
        return {'html': html, 'cookies': cookies}
    
    finally:
        driver.quit()

# Kullanım
result = bypass_with_uc(
    'https://example.com',
    'http://user:pass@proxy.example.com:8080'
)

Sonuç

Proxy üzerinden Cloudflare'ı aşmak, doğru TLS parmak izi, otantik HTTP başlıkları, kaliteli proxy'ler ve iyi bir oturum yönetimi gerektiren karmaşık bir yaklaşımdır. Anahtar öneriler:

• Konut veya mobil proxy'ler kullanın, veri merkezleri yerine
• Doğru TLS parmak izi (tls-client, curl-impersonate) ile kütüphaneler kullanın
• Gelişmiş durumlar için anti-detect yamaları ile headless tarayıcılar kullanın
• cf_clearance çerezlerini saklayın ve yeniden kullanın
• Rate limiting'i dikkate alarak proxy'leri döndürün (IP başına 15-20 istekten fazla değil)
• İstekler arasında rastgele gecikmeler ekleyin (2-5 saniye)

Cloudflare koruması sürekli evrim geçiriyor, bu nedenle araçları düzenli olarak güncellemek ve stratejileri uyarlamak önemlidir. Parmak izi tekniklerindeki değişiklikleri izleyin ve çözümleri güncel koruma sürümlerinde test edin.

Stabil çalışma için geniş bir IP havuzuna ve otomatik döndürmeye sahip profesyonel proxy hizmetleri kullanmanız önerilir.