7 méthodes éprouvées pour contourner la détection de Cloudflare lors de l'utilisation de proxies

Cloudflare traite plus de 20 % de tout le trafic web et utilise un système de protection multi-niveaux contre les bots. Lors de l'utilisation de serveurs proxy, la probabilité de recevoir un captcha ou d'être bloqué augmente considérablement. Dans ce guide, nous examinerons les aspects techniques de la détection et les méthodes pratiques de contournement qui fonctionnent en 2024.

Comment Cloudflare identifie les proxies et les bots

Cloudflare utilise un système d'analyse complexe qui vérifie des dizaines de paramètres pour chaque requête. Comprendre les mécanismes de détection est la première étape pour contourner avec succès la protection.

Principales méthodes de détection

Lors de l'analyse d'une requête, Cloudflare associe le fingerprint TLS au User-Agent déclaré. Si vous spécifiez Chrome 120, mais que les paramètres TLS correspondent à Python requests, cela entraîne une détection instantanée du bot.

Depuis 2023, Cloudflare utilise activement l'apprentissage automatique pour analyser les modèles comportementaux. Le système suit non seulement les paramètres techniques, mais aussi les intervalles de temps entre les requêtes, la séquence des actions de l'utilisateur, les mouvements de la souris et le défilement de la page.

Masquage du fingerprint TLS

Le fingerprinting TLS est la méthode de détection de bots la plus efficace. Les clients HTTP standard (requests, curl, axios) créent un fingerprint qui ne peut pas être confondu avec un véritable navigateur. La solution consiste à utiliser des bibliothèques spécialisées qui imitent le comportement TLS des navigateurs.

Utilisation de curl-impersonate

La bibliothèque curl-impersonate est une version modifiée de curl qui copie exactement les fingerprints TLS et HTTP/2 des navigateurs populaires. Elle prend en charge Chrome, Firefox, Safari et Edge.

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

# Utilisation avec imitation de 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 : bibliothèque tls-client

Pour Python, il existe un wrapper tls-client qui utilise curl-impersonate en arrière-plan et fournit une interface similaire à requests.

import tls_client

# Création d'une session avec fingerprint Chrome 120
session = tls_client.Session(
    client_identifier="chrome_120",
    random_tls_extension_order=True
)

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

# Exécution de la requête
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)

Vérification du fingerprint TLS

Avant de commencer le scraping, il est recommandé de vérifier votre fingerprint TLS. Utilisez les services tls.peet.ws ou ja3er.com pour l'analyse.

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

# Comparez avec le fingerprint d'un vrai Chrome :
# https://kawayiyi.com/tls-fingerprint-database/

Configuration correcte des en-têtes HTTP

Même avec un fingerprint TLS correct, des en-têtes HTTP incorrects trahiront un bot. Cloudflare analyse non seulement la présence des en-têtes, mais aussi leur ordre, le format des valeurs et la cohérence logique.

En-têtes obligatoires pour 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'
}

Les en-têtes Sec-Ch-Ua-* sont apparus dans Chrome 89 et font partie de l'API Client Hints. Leur absence lors de l'utilisation d'un User-Agent moderne est un signe évident de bot.

L'ordre des en-têtes compte

Dans HTTP/2, l'ordre des en-têtes est fixe pour chaque navigateur. Python requests et d'autres clients standard envoient les en-têtes dans l'ordre alphabétique, ce qui diffère du comportement des navigateurs. Utilisez des bibliothèques prenant en charge un ordre d'en-têtes personnalisé.

Génération dynamique de User-Agent

Utiliser le même User-Agent pour toutes les requêtes augmente le risque de détection. Créez un pool de User-Agents actuels et faites-les tourner.

import random

# Pool de User-Agents actuels (décembre 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)
    
    # Adaptation des autres en-têtes au UA choisi
    if 'Chrome' in ua:
        return {
            'User-Agent': ua,
            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
            # ... autres en-têtes Chrome
        }
    elif 'Firefox' in ua:
        return {
            'User-Agent': ua,
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            # ... en-têtes Firefox
        }
    # ... traitement d'autres navigateurs

Utilisation de navigateurs headless

Lorsque Cloudflare utilise un défi JavaScript ou une détection avancée, le seul moyen fiable de contournement est un véritable navigateur. Les navigateurs headless traitent automatiquement le JavaScript, les cookies et créent un fingerprint entièrement authentique.

Playwright avec des patchs anti-detect

Playwright est une alternative moderne à Selenium avec de meilleures performances. Cependant, le Playwright standard est facilement détectable via navigator.webdriver et d'autres marqueurs. Utilisez playwright-stealth pour le masquage.

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)  # Application des patchs anti-detect
        
        # Accéder à la page
        page.goto(url, wait_until='networkidle', timeout=30000)
        
        # Attendre la réussite du défi Cloudflare (généralement 5-10 secondes)
        page.wait_for_timeout(8000)
        
        # Vérification du contournement réussi
        if 'Just a moment' in page.content():
            print('Défi Cloudflare non réussi')
            return None
        
        # Extraction des cookies pour une utilisation ultérieure
        cookies = context.cookies()
        html = page.content()
        
        browser.close()
        return {'html': html, 'cookies': cookies}

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

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

Puppeteer Extra avec des plugins

Pour l'écosystème Node.js, la meilleure solution est puppeteer-extra avec le plugin puppeteer-extra-plugin-stealth. Ce plugin applique plus de 30 techniques de masquage de l'automatisation.

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();
    
    // Configuration du viewport et du user-agent
    await page.setViewport({ width: 1920, height: 1080 });
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
    
    // Redéfinition de navigator.webdriver
    await page.evaluateOnNewDocument(() => {
        delete Object.getPrototypeOf(navigator).webdriver;
    });
    
    // Accéder à la page
    await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
    
    // Attendre le passage du défi
    await page.waitForTimeout(8000);
    
    // Obtention du contenu et des cookies
    const content = await page.content();
    const cookies = await page.cookies();
    
    await browser.close();
    
    return { content, cookies };
}

// Exemple d'utilisation
bypassCloudflare('https://example.com', 'http://user:pass@proxy.example.com:8080')
    .then(result => console.log('Succès'))
    .catch(err => console.error(err));

Choix du type de proxy pour le contournement de Cloudflare

Le type de proxy influence de manière critique le succès du contournement. Cloudflare maintient des bases de données d'adresses IP des centres de données et applique des règles de vérification plus strictes.

Pourquoi les proxies résidentiels sont plus efficaces

Les proxies résidentiels utilisent des adresses IP de véritables appareils (routeurs domestiques, smartphones). Cloudflare ne peut pas bloquer massivement ces IP, car cela bloquerait les utilisateurs ordinaires. Les statistiques montrent que les IP résidentielles reçoivent un captcha 15 à 20 fois moins souvent que les centres de données.

Lors de l'utilisation de proxies résidentiels, la géolocalisation est cruciale. Si le site cible est orienté vers les États-Unis, l'utilisation de proxies d'Asie augmentera la suspicion. Choisissez des fournisseurs avec une large couverture géographique et la possibilité de cibler par ville.

Proxies mobiles pour une fiabilité maximale

Les proxies mobiles utilisent des adresses IP des opérateurs mobiles (4G/5G). La particularité des réseaux mobiles est le changement dynamique d'IP via le mode avion, ce qui permet d'avoir pratiquement un nombre illimité d'adresses IP propres. La probabilité de blocage d'une IP mobile est proche de zéro.

# Exemple de rotation d'IP mobile via API
import requests
import time

def rotate_mobile_ip(proxy_api_url):
    """Changement d'IP du proxy mobile"""
    response = requests.get(f"{proxy_api_url}/rotate")
    if response.status_code == 200:
        print("IP changée avec succès")
        time.sleep(5)  # Attente de l'application des changements
        return True
    return False

# Utilisation avec un proxy mobile
mobile_proxy = "http://user:pass@mobile.proxy.com:8080"

for i in range(10):
    # Exécution de la requête
    response = requests.get(
        'https://example.com',
        proxies={'http': mobile_proxy, 'https': mobile_proxy}
    )
    
    # Rotation de l'IP après chaque requête
    rotate_mobile_ip('https://api.proxy.com/mobile')

Gestion des cookies et des sessions

Après avoir réussi le défi Cloudflare, le serveur établit des cookies (cf_clearance, __cfduid et autres) qui confirment la légitimité du client. Une gestion correcte de ces cookies permet d'éviter des vérifications répétées.

Extraction et réutilisation de cf_clearance

Le cookie cf_clearance est généralement valide pendant 30 à 60 minutes. Après l'avoir obtenu via un navigateur headless, il peut être utilisé dans des requêtes HTTP ordinaires.

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):
        """Chargement des cookies sauvegardés"""
        try:
            with open(self.cookie_file, 'rb') as f:
                data = pickle.load(f)
                # Vérification de la durée de validité
                if data['expires'] > datetime.now():
                    return data['cookies']
        except FileNotFoundError:
            pass
        return None
    
    def save_cookies(self, cookies, ttl_minutes=30):
        """Sauvegarde des cookies avec 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):
        """Obtention de cf_clearance via le navigateur"""
        if self.cookies:
            return self.cookies
        
        # Ici, le code pour lancer le navigateur (de la section précédente)
        # ...
        browser_cookies = bypass_cloudflare(url, proxy)['cookies']
        
        # Conversion au 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):
        """Requête avec gestion automatique des cookies"""
        cookies = self.get_cf_clearance(url, proxy)
        
        response = requests.get(
            url,
            cookies=cookies,
            proxies={'http': proxy, 'https': proxy},
            headers=get_random_headers()
        )
        
        # Si nous recevons à nouveau un défi — mettons à jour les cookies
        if response.status_code == 403 or 'cf-browser-verification' in response.text:
            print("Cookies obsolètes, obtention de nouveaux...")
            self.cookies = None
            return self.make_request(url, proxy)
        
        return response

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

Liaison des cookies à l'adresse IP

Cloudflare lie cf_clearance à l'adresse IP à partir de laquelle le défi a été réussi. L'utilisation de ce cookie avec une autre IP entraînera un blocage. Lors de l'utilisation de proxies rotatifs, il est nécessaire de conserver un ensemble de cookies distinct pour chaque IP.

import hashlib

class IPBoundCookieManager:
    def __init__(self):
        self.cookies_by_ip = {}
    
    def get_ip_hash(self, proxy_url):
        """Création d'un hash pour identifier le proxy"""
        return hashlib.md5(proxy_url.encode()).hexdigest()
    
    def get_cookies_for_proxy(self, proxy_url, target_url):
        """Obtention des cookies pour un proxy spécifique"""
        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']
        
        # Obtention de nouveaux cookies via le navigateur
        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

Rotation des proxies et contrôle de la fréquence des requêtes

Même avec la bonne pile technique, une fréquence de requêtes trop élevée à partir d'une seule IP déclenche le rate limiting. Cloudflare analyse les modèles de trafic et détecte l'activité anormale.

Stratégies de rotation des proxies

Il existe trois approches principales pour la rotation : round-robin (séquentielle), random (aléatoire) et sticky sessions (liaison à la session). Pour contourner Cloudflare, la stratégie optimale est les sticky sessions avec une limitation des requêtes par 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
        
        # Compteurs d'utilisation
        self.usage_count = defaultdict(int)
        self.last_used = {}
        self.cooldown_until = {}
    
    def get_proxy(self):
        """Obtention du prochain proxy disponible"""
        available_proxies = []
        
        for proxy in self.proxy_list:
            # Vérification du cooldown
            if proxy in self.cooldown_until:
                if datetime.now() < self.cooldown_until[proxy]:
                    continue
                else:
                    # Réinitialisation du compteur après le cooldown
                    self.usage_count[proxy] = 0
                    del self.cooldown_until[proxy]
            
            # Vérification de la limite de requêtes
            if self.usage_count[proxy] < self.max_requests_per_ip:
                available_proxies.append(proxy)
        
        if not available_proxies:
            # Si tous les proxies sont en cooldown — attendons
            wait_time = min(
                (self.cooldown_until[p] - datetime.now()).total_seconds()
                for p in self.cooldown_until
            )
            print(f"Tous les proxies sont en cooldown. Attente de {wait_time:.0f} secondes...")
            time.sleep(wait_time + 1)
            return self.get_proxy()
        
        # Choix du proxy avec le moins d'utilisation
        proxy = min(available_proxies, key=lambda p: self.usage_count[p])
        
        self.usage_count[proxy] += 1
        self.last_used[proxy] = datetime.now()
        
        # Mise en place du cooldown lors de l'atteinte de la limite
        if self.usage_count[proxy] >= self.max_requests_per_ip:
            self.cooldown_until[proxy] = datetime.now() + timedelta(
                minutes=self.cooldown_minutes
            )
            print(f"Le proxy {proxy} a atteint la limite. Cooldown de {self.cooldown_minutes} minutes.")
        
        return proxy
    
    def add_delay(self):
        """Délai aléatoire entre les requêtes (imitation d'un humain)"""
        delay = random.uniform(2, 5)  # 2-5 secondes
        time.sleep(delay)

# Utilisation
proxy_pool = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
    # ... jusqu'à 50-100 proxies pour un fonctionnement stable
]

rotator = SmartProxyRotator(
    proxy_pool,
    max_requests_per_ip=15,  # Valeur conservatrice
    cooldown_minutes=15
)

# Exécution des requêtes
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"Requête {i+1}: {response.status_code}")
    rotator.add_delay()

Limitation adaptative des taux

Une approche plus avancée consiste à adapter dynamiquement la fréquence des requêtes en fonction des réponses du serveur. Si des erreurs 429 ou des captchas commencent à apparaître, réduisez automatiquement le rythme.

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):
        """Requête réussie — on peut accélérer"""
        self.success_streak += 1
        self.failure_streak = 0
        
        if self.success_streak >= 10:
            # Réduction du délai de 10 %
            self.delay = max(self.min_delay, self.delay * 0.9)
            self.success_streak = 0
    
    def on_failure(self, status_code):
        """Erreur — on ralentit"""
        self.failure_streak += 1
        self.success_streak = 0
        
        if status_code == 429:  # Limite de taux
            # Ralentissement agressif
            self.delay = min(self.max_delay, self.delay * 2.0)
        elif status_code == 403:  # Possible blocage
            self.delay = min(self.max_delay, self.delay * 1.5)
        
        print(f"Délai augmenté à {self.delay:.2f}s")
    
    def wait(self):
        """Attente avant la prochaine requête"""
        # Ajout d'aléatoire ±20%
        actual_delay = self.delay * random.uniform(0.8, 1.2)
        time.sleep(actual_delay)

Outils et bibliothèques prêts à l'emploi pour le contournement

Développer sa propre solution depuis zéro demande du temps et de l'expertise. Il existe des outils prêts à l'emploi qui automatisent le processus de contournement de Cloudflare.

cloudscraper (Python)

La bibliothèque cloudscraper est une surcouche de requests qui résout automatiquement les défis JavaScript. Elle fonctionne avec les protections de base, mais peut ne pas réussir face à des vérifications avancées.

import cloudscraper

# Création d'un scraper avec support de proxy
scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

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

# Exécution de la requête
response = scraper.get('https://example.com', proxies=proxies)

if response.status_code == 200:
    print("Contournement réussi")
    print(response.text)
else:
    print(f"Erreur : {response.status_code}")

FlareSolverr (universel)

FlareSolverr est un serveur proxy qui exécute un navigateur headless pour résoudre les défis Cloudflare. Il fonctionne via une API HTTP et prend en charge tous les langages de programmation.

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

# Utilisation depuis 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"Erreur FlareSolverr : {result['message']}")

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

print(result['html'])

undetected-chromedriver

Version patchée de Selenium ChromeDriver qui applique automatiquement de nombreuses techniques anti-detect. Plus facile à utiliser que Playwright, mais moins flexible.

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)
        
        # Attente de la disparition du défi Cloudflare
        WebDriverWait(driver, 20).until_not(
            EC.presence_of_element_located((By.ID, "cf-spinner-please-wait"))
        )
        
        # Attente supplémentaire pour la fiabilité
        time.sleep(3)
        
        # Obtention du résultat
        html = driver.page_source
        cookies = driver.get_cookies()
        
        return {'html': html, 'cookies': cookies}
    
    finally:
        driver.quit()

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

Conclusion

Contourner Cloudflare lors de l'utilisation de proxies nécessite une approche globale : un fingerprint TLS correct, des en-têtes HTTP authentiques, des proxies de qualité et une gestion adéquate des sessions. Recommandations clés :

• Utilisez des proxies résidentiels ou mobiles au lieu de centres de données
• Appliquez des bibliothèques avec un fingerprint TLS correct (tls-client, curl-impersonate)
• Pour des cas complexes, utilisez des navigateurs headless avec des patchs anti-detect
• Conservez et réutilisez les cookies cf_clearance
• Faites tourner les proxies en tenant compte du rate limiting (pas plus de 15-20 requêtes par IP)
• Ajoutez des délais aléatoires entre les requêtes (2-5 secondes)

La protection Cloudflare évolue constamment, il est donc important de mettre à jour régulièrement les outils et d'adapter les stratégies. Surveillez les changements dans les techniques de fingerprinting et testez les solutions sur les versions actuelles de la protection.

Pour un fonctionnement stable, il est recommandé d'utiliser des services de proxy professionnels avec un large pool d'IP et une rotation automatique.