7 cara teruji untuk melewati deteksi Cloudflare saat bekerja melalui proxy

Cloudflare memproses lebih dari 20% dari seluruh lalu lintas web dan menggunakan sistem perlindungan multi-level terhadap bot. Saat bekerja melalui server proxy, kemungkinan untuk mendapatkan captcha atau pemblokiran meningkat secara signifikan. Dalam panduan ini, kita akan membahas aspek teknis deteksi dan metode praktis untuk melewatinya yang berfungsi pada tahun 2024.

Bagaimana Cloudflare mendeteksi proxy dan bot

Cloudflare menggunakan sistem analisis komprehensif yang memeriksa puluhan parameter dari setiap permintaan. Memahami mekanisme deteksi adalah langkah pertama untuk berhasil melewati perlindungan.

Metode deteksi utama

Saat menganalisis permintaan, Cloudflare mencocokkan TLS fingerprint dengan User-Agent yang dinyatakan. Jika Anda menyebutkan Chrome 120, tetapi parameter TLS sesuai dengan Python requests — ini adalah deteksi bot yang instan.

Sejak 2023, Cloudflare secara aktif menggunakan pembelajaran mesin untuk menganalisis pola perilaku. Sistem ini tidak hanya melacak parameter teknis, tetapi juga interval waktu antara permintaan, urutan tindakan pengguna, gerakan mouse, dan scroll halaman.

Menyamarkan TLS fingerprint

TLS fingerprinting adalah metode deteksi bot yang paling efektif. Klien HTTP standar (requests, curl, axios) menghasilkan fingerprint yang tidak dapat dibedakan dari browser nyata. Solusinya adalah menggunakan pustaka khusus yang meniru perilaku TLS browser.

Menggunakan curl-impersonate

Pustaka curl-impersonate adalah versi modifikasi dari curl yang meniru dengan tepat TLS dan HTTP/2 fingerprints dari browser populer. Mendukung Chrome, Firefox, Safari, dan Edge.

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

# Menggunakan dengan meniru 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: pustaka tls-client

Untuk Python, ada pembungkus tls-client yang menggunakan curl-impersonate di belakang layar dan menyediakan antarmuka yang mirip dengan requests.

import tls_client

# Membuat sesi dengan fingerprint Chrome 120
session = tls_client.Session(
    client_identifier="chrome_120",
    random_tls_extension_order=True
)

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

# Melakukan permintaan
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)

Memeriksa TLS fingerprint

Sebelum memulai pengambilan data, disarankan untuk memeriksa TLS fingerprint Anda. Gunakan layanan tls.peet.ws atau ja3er.com untuk analisis.

# Memeriksa fingerprint
response = session.get('https://tls.peet.ws/api/all')
print(response.json()['tls']['ja3'])

# Bandingkan dengan fingerprint Chrome nyata:
# https://kawayiyi.com/tls-fingerprint-database/

Pengaturan HTTP header yang benar

Bahkan dengan TLS fingerprint yang benar, HTTP header yang salah akan mengungkapkan bot. Cloudflare menganalisis tidak hanya keberadaan header, tetapi juga urutan, format nilai, dan konsistensi logis.

Header wajib untuk 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'
}

Header Sec-Ch-Ua-* muncul di Chrome 89 dan merupakan bagian dari Client Hints API. Ketidakhadirannya saat menggunakan User-Agent modern adalah tanda jelas bot.

Urutan header itu penting

Di HTTP/2, urutan header tetap untuk setiap browser. Python requests dan klien standar lainnya mengirimkan header dalam urutan alfabetis, yang berbeda dari perilaku browser. Gunakan pustaka yang mendukung urutan header kustom.

Generasi dinamis User-Agent

Menggunakan User-Agent yang sama untuk semua permintaan meningkatkan risiko deteksi. Buat kumpulan User-Agent yang relevan dan rotasi mereka.

import random

# Kumpulan User-Agent yang relevan (Desember 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)
    
    # Penyesuaian header lain sesuai dengan UA yang dipilih
    if 'Chrome' in ua:
        return {
            'User-Agent': ua,
            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
            # ... header Chrome lainnya
        }
    elif 'Firefox' in ua:
        return {
            'User-Agent': ua,
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            # ... header Firefox
        }
    # ... penanganan browser lainnya

Menggunakan browser headless

Ketika Cloudflare menggunakan tantangan JavaScript atau deteksi canggih, satu-satunya cara yang dapat diandalkan untuk melewati adalah dengan menggunakan browser nyata. Browser headless secara otomatis menangani JavaScript, cookies, dan menghasilkan fingerprint yang sepenuhnya autentik.

Playwright dengan patch anti-detect

Playwright adalah alternatif modern untuk Selenium dengan kinerja yang lebih baik. Namun, Playwright standar mudah terdeteksi melalui navigator.webdriver dan marker lainnya. Gunakan playwright-stealth untuk menyamarkan.

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)  # Menerapkan patch anti-detect
        
        # Mengunjungi halaman
        page.goto(url, wait_until='networkidle', timeout=30000)
        
        # Menunggu melewati tantangan Cloudflare (biasanya 5-10 detik)
        page.wait_for_timeout(8000)
        
        # Memeriksa keberhasilan bypass
        if 'Just a moment' in page.content():
            print('Tantangan Cloudflare tidak terlewati')
            return None
        
        # Mengambil cookies untuk penggunaan selanjutnya
        cookies = context.cookies()
        html = page.content()
        
        browser.close()
        return {'html': html, 'cookies': cookies}

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

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

Puppeteer Extra dengan plugin

Untuk ekosistem Node.js, solusi terbaik adalah puppeteer-extra dengan plugin puppeteer-extra-plugin-stealth. Plugin ini menerapkan lebih dari 30 teknik penyamaran otomatisasi yang berbeda.

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();
    
    // Mengatur viewport dan user-agent
    await page.setViewport({ width: 1920, height: 1080 });
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
    
    // Menghapus navigator.webdriver
    await page.evaluateOnNewDocument(() => {
        delete Object.getPrototypeOf(navigator).webdriver;
    });
    
    // Mengunjungi halaman
    await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
    
    // Menunggu melewati tantangan
    await page.waitForTimeout(8000);
    
    // Mengambil konten dan cookies
    const content = await page.content();
    const cookies = await page.cookies();
    
    await browser.close();
    
    return { content, cookies };
}

// Contoh penggunaan
bypassCloudflare('https://example.com', 'http://user:pass@proxy.example.com:8080')
    .then(result => console.log('Sukses'))
    .catch(err => console.error(err));

Memilih jenis proxy untuk bypass Cloudflare

Jenis proxy secara kritis mempengaruhi keberhasilan bypass. Cloudflare memiliki basis data IP alamat pusat data dan menerapkan aturan pemeriksaan yang lebih ketat.

Mengapa proxy residential lebih efektif

Proxy residential menggunakan alamat IP dari perangkat nyata (router rumah, smartphone). Cloudflare tidak dapat memblokir IP ini secara massal karena akan memblokir pengguna biasa. Statistik menunjukkan bahwa IP residential mendapatkan captcha 15-20 kali lebih jarang dibandingkan dengan pusat data.

Saat bekerja dengan proxy residential, geolokasi sangat penting. Jika situs target berorientasi pada AS, menggunakan proxy dari Asia akan meningkatkan kecurigaan. Pilih penyedia dengan jangkauan geografis yang luas dan kemampuan penargetan berdasarkan kota.

Proxy mobile untuk keandalan maksimum

Proxy mobile menggunakan alamat IP dari operator seluler (4G/5G). Ciri khas jaringan seluler adalah pergantian IP yang dinamis melalui mode pesawat, yang memberikan jumlah IP bersih yang hampir tidak terbatas. Kemungkinan pemblokiran IP mobile mendekati nol.

# Contoh rotasi IP mobile melalui API
import requests
import time

def rotate_mobile_ip(proxy_api_url):
    """Mengganti IP proxy mobile"""
    response = requests.get(f"{proxy_api_url}/rotate")
    if response.status_code == 200:
        print("IP berhasil diubah")
        time.sleep(5)  # Menunggu penerapan perubahan
        return True
    return False

# Penggunaan dengan proxy mobile
mobile_proxy = "http://user:pass@mobile.proxy.com:8080"

for i in range(10):
    # Melakukan permintaan
    response = requests.get(
        'https://example.com',
        proxies={'http': mobile_proxy, 'https': mobile_proxy}
    )
    
    # Rotasi IP setelah setiap permintaan
    rotate_mobile_ip('https://api.proxy.com/mobile')

Mengelola cookies dan sesi

Setelah berhasil melewati tantangan Cloudflare, server mengatur cookies (cf_clearance, __cfduid, dan lainnya) yang mengonfirmasi legitimasi klien. Mengelola cookies ini dengan benar memungkinkan untuk menghindari pemeriksaan ulang.

Mengambil dan menggunakan kembali cf_clearance

Cookie cf_clearance biasanya berlaku selama 30-60 menit. Setelah diterima melalui browser headless, cookie ini dapat digunakan dalam permintaan HTTP biasa.

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):
        """Memuat cookies yang disimpan"""
        try:
            with open(self.cookie_file, 'rb') as f:
                data = pickle.load(f)
                # Memeriksa masa berlaku
                if data['expires'] > datetime.now():
                    return data['cookies']
        except FileNotFoundError:
            pass
        return None
    
    def save_cookies(self, cookies, ttl_minutes=30):
        """Menyimpan cookies dengan 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):
        """Mendapatkan cf_clearance melalui browser"""
        if self.cookies:
            return self.cookies
        
        # Di sini kode untuk menjalankan browser (dari bagian sebelumnya)
        # ...
        browser_cookies = bypass_cloudflare(url, proxy)['cookies']
        
        # Mengonversi ke format 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):
        """Permintaan dengan pengelolaan cookies otomatis"""
        cookies = self.get_cf_clearance(url, proxy)
        
        response = requests.get(
            url,
            cookies=cookies,
            proxies={'http': proxy, 'https': proxy},
            headers=get_random_headers()
        )
        
        # Jika mendapatkan tantangan lagi — perbarui cookies
        if response.status_code == 403 or 'cf-browser-verification' in response.text:
            print("Cookies sudah kadaluarsa, mendapatkan yang baru...")
            self.cookies = None
            return self.make_request(url, proxy)
        
        return response

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

Mengikat cookies ke alamat IP

Cloudflare mengikat cf_clearance ke alamat IP dari mana tantangan dilalui. Menggunakan cookie ini dari IP lain akan menyebabkan pemblokiran. Saat bekerja dengan proxy yang berotasi, perlu menyimpan set cookies terpisah untuk setiap IP.

import hashlib

class IPBoundCookieManager:
    def __init__(self):
        self.cookies_by_ip = {}
    
    def get_ip_hash(self, proxy_url):
        """Membuat hash untuk identifikasi proxy"""
        return hashlib.md5(proxy_url.encode()).hexdigest()
    
    def get_cookies_for_proxy(self, proxy_url, target_url):
        """Mendapatkan cookies untuk proxy tertentu"""
        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']
        
        # Mendapatkan cookies baru melalui browser
        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

Rotasi proxy dan kontrol frekuensi permintaan

Bahkan dengan tumpukan teknis yang benar, frekuensi permintaan yang terlalu tinggi dari satu IP akan memicu rate limiting. Cloudflare menganalisis pola lalu lintas dan mendeteksi aktivitas yang tidak normal.

Strategi rotasi proxy

Ada tiga pendekatan utama untuk rotasi: round-robin (berurutan), random (acak), dan sticky sessions (ikatan ke sesi). Untuk melewati Cloudflare, strategi sticky sessions dengan pembatasan permintaan per IP adalah yang paling optimal.

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
        
        # Penghitung penggunaan
        self.usage_count = defaultdict(int)
        self.last_used = {}
        self.cooldown_until = {}
    
    def get_proxy(self):
        """Mendapatkan proxy berikutnya yang tersedia"""
        available_proxies = []
        
        for proxy in self.proxy_list:
            # Memeriksa cooldown
            if proxy in self.cooldown_until:
                if datetime.now() < self.cooldown_until[proxy]:
                    continue
                else:
                    # Mereset penghitung setelah cooldown
                    self.usage_count[proxy] = 0
                    del self.cooldown_until[proxy]
            
            # Memeriksa batas permintaan
            if self.usage_count[proxy] < self.max_requests_per_ip:
                available_proxies.append(proxy)
        
        if not available_proxies:
            # Jika semua proxy dalam cooldown — tunggu
            wait_time = min(
                (self.cooldown_until[p] - datetime.now()).total_seconds()
                for p in self.cooldown_until
            )
            print(f"Semua proxy dalam cooldown. Menunggu {wait_time:.0f} detik...")
            time.sleep(wait_time + 1)
            return self.get_proxy()
        
        # Memilih proxy dengan penggunaan terendah
        proxy = min(available_proxies, key=lambda p: self.usage_count[p])
        
        self.usage_count[proxy] += 1
        self.last_used[proxy] = datetime.now()
        
        # Mengatur cooldown saat mencapai batas
        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} telah mencapai batas. Cooldown {self.cooldown_minutes} menit.")
        
        return proxy
    
    def add_delay(self):
        """Penundaan acak antara permintaan (meniru manusia)"""
        delay = random.uniform(2, 5)  # 2-5 detik
        time.sleep(delay)

# Penggunaan
proxy_pool = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
    # ... hingga 50-100 proxy untuk operasi yang stabil
]

rotator = SmartProxyRotator(
    proxy_pool,
    max_requests_per_ip=15,  # Nilai konservatif
    cooldown_minutes=15
)

# Melakukan permintaan
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"Permintaan {i+1}: {response.status_code}")
    rotator.add_delay()

Adaptive rate limiting

Pendekatan yang lebih maju adalah penyesuaian dinamis frekuensi permintaan berdasarkan respons server. Jika mulai muncul kesalahan 429 atau captcha, secara otomatis kurangi tempo.

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):
        """Permintaan berhasil — bisa mempercepat"""
        self.success_streak += 1
        self.failure_streak = 0
        
        if self.success_streak >= 10:
            # Mengurangi penundaan sebesar 10%
            self.delay = max(self.min_delay, self.delay * 0.9)
            self.success_streak = 0
    
    def on_failure(self, status_code):
        """Kesalahan — melambat"""
        self.failure_streak += 1
        self.success_streak = 0
        
        if status_code == 429:  # Rate limit
            # Melambat secara agresif
            self.delay = min(self.max_delay, self.delay * 2.0)
        elif status_code == 403:  # Kemungkinan pemblokiran
            self.delay = min(self.max_delay, self.delay * 1.5)
        
        print(f"Penundaan meningkat menjadi {self.delay:.2f}s")
    
    def wait(self):
        """Menunggu sebelum permintaan berikutnya"""
        # Menambahkan kebetulan ±20%
        actual_delay = self.delay * random.uniform(0.8, 1.2)
        time.sleep(actual_delay)

Alat dan pustaka siap pakai untuk bypass

Mengembangkan solusi sendiri dari nol membutuhkan waktu dan keahlian. Ada alat siap pakai yang mengotomatiskan proses bypass Cloudflare.

cloudscraper (Python)

Pustaka cloudscraper adalah lapisan di atas requests yang secara otomatis menyelesaikan tantangan JavaScript. Bekerja dengan perlindungan dasar, tetapi mungkin tidak dapat menangani pemeriksaan yang lebih canggih.

import cloudscraper

# Membuat scraper dengan dukungan proxy
scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

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

# Melakukan permintaan
response = scraper.get('https://example.com', proxies=proxies)

if response.status_code == 200:
    print("BYPASS berhasil")
    print(response.text)
else:
    print(f"Kesalahan: {response.status_code}")

FlareSolverr (universal)

FlareSolverr adalah server proxy yang menjalankan browser headless untuk menyelesaikan tantangan Cloudflare. Bekerja melalui API HTTP, mendukung bahasa pemrograman apa pun.

# Menjalankan FlareSolverr melalui Docker
docker run -d \
  --name=flaresolverr \
  -p 8191:8191 \
  -e LOG_LEVEL=info \
  ghcr.io/flaresolverr/flaresolverr:latest

# Penggunaan dari 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"Kesalahan FlareSolverr: {result['message']}")

# Contoh penggunaan
result = solve_cloudflare(
    'https://example.com',
    proxy='http://user:pass@proxy.example.com:8080'
)

print(result['html'])

undetected-chromedriver

Versi patch dari Selenium ChromeDriver yang secara otomatis menerapkan banyak teknik anti-detect. Lebih mudah digunakan daripada Playwright, tetapi kurang fleksibel.

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)
        
        # Menunggu tantangan Cloudflare hilang
        WebDriverWait(driver, 20).until_not(
            EC.presence_of_element_located((By.ID, "cf-spinner-please-wait"))
        )
        
        # Penantian tambahan untuk keandalan
        time.sleep(3)
        
        # Mengambil hasil
        html = driver.page_source
        cookies = driver.get_cookies()
        
        return {'html': html, 'cookies': cookies}
    
    finally:
        driver.quit()

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

Kesimpulan

Melewati Cloudflare saat bekerja melalui proxy membutuhkan pendekatan komprehensif: fingerprint TLS yang benar, header HTTP yang autentik, proxy berkualitas, dan pengelolaan sesi yang cermat. Rekomendasi kunci:

• Gunakan proxy residential atau proxy mobile daripada pusat data
• Gunakan pustaka dengan fingerprint TLS yang benar (tls-client, curl-impersonate)
• Untuk kasus yang kompleks, gunakan browser headless dengan patch anti-detect
• Simpan dan gunakan kembali cookies cf_clearance
• Rotasi proxy dengan mempertimbangkan rate limiting (tidak lebih dari 15-20 permintaan per IP)
• Tambahkan penundaan acak antara permintaan (2-5 detik)

Perlindungan Cloudflare terus berkembang, jadi penting untuk secara teratur memperbarui alat dan menyesuaikan strategi. Pantau perubahan dalam teknik fingerprinting dan uji solusi pada versi perlindungan yang terbaru.

Untuk operasi yang stabil, disarankan untuk menggunakan layanan proxy profesional dengan kumpulan IP yang luas dan rotasi otomatis.