7 metodi collaudati per bypassare la rilevazione di Cloudflare quando si utilizza un proxy

Cloudflare gestisce oltre il 20% di tutto il traffico web e utilizza un sistema di protezione multilivello contro i bot. Quando si utilizza un server proxy, la probabilità di ricevere un captcha o un blocco aumenta notevolmente. In questa guida esploreremo gli aspetti tecnici della rilevazione e i metodi pratici di bypass che funzionano nel 2024.

Come Cloudflare identifica proxy e bot

Cloudflare utilizza un sistema di analisi complesso che verifica decine di parametri per ogni richiesta. Comprendere i meccanismi di rilevazione è il primo passo per un bypass efficace della protezione.

Principali metodi di rilevazione

Quando analizza una richiesta, Cloudflare confronta il TLS fingerprint con l'User-Agent dichiarato. Se dichiari Chrome 120, ma i parametri TLS corrispondono a Python requests, si tratta di una rilevazione immediata di un bot.

Dal 2023, Cloudflare utilizza attivamente il machine learning per analizzare i pattern comportamentali. Il sistema monitora non solo i parametri tecnici, ma anche gli intervalli di tempo tra le richieste, la sequenza delle azioni dell'utente, i movimenti del mouse e lo scroll della pagina.

Mascheramento del TLS fingerprint

Il TLS fingerprinting è il metodo di rilevazione dei bot più efficace. I client HTTP standard (requests, curl, axios) generano un fingerprint che non può essere confuso con un browser reale. La soluzione è utilizzare librerie specializzate che imitano il comportamento TLS dei browser.

Utilizzo di curl-impersonate

La libreria curl-impersonate è una versione modificata di curl che copia esattamente i fingerprint TLS e HTTP/2 dei browser più popolari. Supporta Chrome, Firefox, Safari ed Edge.

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

# Utilizzo con imitazione di 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: libreria tls-client

Per Python esiste un wrapper tls-client, che utilizza curl-impersonate sotto il cofano e fornisce un'interfaccia simile a requests.

import tls_client

# Creazione di una sessione con fingerprint Chrome 120
session = tls_client.Session(
    client_identifier="chrome_120",
    random_tls_extension_order=True
)

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

# Esecuzione della richiesta
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)

Verifica del TLS fingerprint

Prima di iniziare il parsing, è consigliabile verificare il proprio TLS fingerprint. Utilizza i servizi tls.peet.ws o ja3er.com per l'analisi.

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

# Confronta con il fingerprint di Chrome reale:
# https://kawayiyi.com/tls-fingerprint-database/

Configurazione corretta degli header HTTP

Anche con un TLS fingerprint corretto, header HTTP errati riveleranno un bot. Cloudflare analizza non solo la presenza degli header, ma anche il loro ordine, il formato dei valori e la coerenza logica.

Header obbligatori per 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'
}

Gli header Sec-Ch-Ua-* sono apparsi in Chrome 89 e fanno parte dell'API Client Hints. La loro assenza quando si utilizza un User-Agent moderno è un chiaro segno di un bot.

L'ordine degli header è importante

In HTTP/2, l'ordine degli header è fisso per ogni browser. Python requests e altri client standard inviano gli header in ordine alfabetico, il che è diverso dal comportamento dei browser. Utilizza librerie che supportano un ordine personalizzato degli header.

Generazione dinamica dell'User-Agent

Utilizzare lo stesso User-Agent per tutte le richieste aumenta il rischio di rilevazione. Crea un pool di User-Agent attuali e ruotali.

import random

# Pool di User-Agent attuali (dicembre 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)
    
    # Adattamento degli altri header al UA scelto
    if 'Chrome' in ua:
        return {
            'User-Agent': ua,
            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
            # ... altri header di Chrome
        }
    elif 'Firefox' in ua:
        return {
            'User-Agent': ua,
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            # ... header di Firefox
        }
    # ... gestione di altri browser

Utilizzo di browser headless

Quando Cloudflare utilizza una sfida JavaScript o una rilevazione avanzata, l'unico modo affidabile per bypassare è utilizzare un browser reale. I browser headless gestiscono automaticamente JavaScript, cookies e creano un fingerprint completamente autentico.

Playwright con patch anti-detect

Playwright è un'alternativa moderna a Selenium con prestazioni migliori. Tuttavia, il Playwright standard è facilmente rilevabile tramite navigator.webdriver e altri indicatori. Utilizza playwright-stealth per mascherare.

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)  # Applicazione delle patch anti-detect
        
        # Navigazione alla pagina
        page.goto(url, wait_until='networkidle', timeout=30000)
        
        # Attesa per il superamento della sfida Cloudflare (di solito 5-10 secondi)
        page.wait_for_timeout(8000)
        
        # Verifica del bypass riuscito
        if 'Just a moment' in page.content():
            print('Sfida Cloudflare non superata')
            return None
        
        # Estrazione dei cookies per uso futuro
        cookies = context.cookies()
        html = page.content()
        
        browser.close()
        return {'html': html, 'cookies': cookies}

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

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

Puppeteer Extra con plugin

Per l'ecosistema Node.js, la soluzione migliore è puppeteer-extra con il plugin puppeteer-extra-plugin-stealth. Questo plugin applica oltre 30 tecniche diverse di mascheramento dell'automazione.

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();
    
    // Impostazione del viewport e dell'user-agent
    await page.setViewport({ width: 1920, height: 1080 });
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
    
    // Ridefinizione di navigator.webdriver
    await page.evaluateOnNewDocument(() => {
        delete Object.getPrototypeOf(navigator).webdriver;
    });
    
    // Navigazione alla pagina
    await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
    
    // Attesa per il superamento della sfida
    await page.waitForTimeout(8000);
    
    // Ottenimento del contenuto e dei cookies
    const content = await page.content();
    const cookies = await page.cookies();
    
    await browser.close();
    
    return { content, cookies };
}

// Esempio di utilizzo
bypassCloudflare('https://example.com', 'http://user:pass@proxy.example.com:8080')
    .then(result => console.log('Successo'))
    .catch(err => console.error(err));

Scelta del tipo di proxy per il bypass di Cloudflare

Il tipo di proxy influisce in modo critico sul successo del bypass. Cloudflare mantiene database di indirizzi IP dei data center e applica regole di controllo più severe a questi.

Perché i proxy residenziali sono più efficaci

I proxy residenziali utilizzano indirizzi IP di dispositivi reali (router domestici, smartphone). Cloudflare non può bloccare massicciamente tali IP, poiché ciò bloccherebbe gli utenti normali. Le statistiche mostrano che gli IP residenziali ricevono captcha 15-20 volte meno frequentemente rispetto ai data center.

Quando si lavora con proxy residenziali, la geolocalizzazione è fondamentale. Se il sito target è orientato agli Stati Uniti, l'uso di proxy dall'Asia aumenterà la sospettosità. Scegli fornitori con una vasta geografia e la possibilità di targeting per città.

Proxy mobili per la massima affidabilità

I proxy mobili utilizzano indirizzi IP di operatori mobili (4G/5G). La caratteristica delle reti mobili è il cambio dinamico di IP tramite la modalità aereo, il che offre praticamente un numero illimitato di indirizzi IP puliti. La probabilità di blocco di un IP mobile è prossima a zero.

# Esempio di rotazione dell'IP mobile tramite API
import requests
import time

def rotate_mobile_ip(proxy_api_url):
    """Cambio IP del proxy mobile"""
    response = requests.get(f"{proxy_api_url}/rotate")
    if response.status_code == 200:
        print("IP cambiato con successo")
        time.sleep(5)  # Attesa per l'applicazione delle modifiche
        return True
    return False

# Utilizzo con proxy mobile
mobile_proxy = "http://user:pass@mobile.proxy.com:8080"

for i in range(10):
    # Esecuzione della richiesta
    response = requests.get(
        'https://example.com',
        proxies={'http': mobile_proxy, 'https': mobile_proxy}
    )
    
    # Rotazione dell'IP dopo ogni richiesta
    rotate_mobile_ip('https://api.proxy.com/mobile')

Gestione di cookies e sessioni

Dopo aver superato con successo la sfida di Cloudflare, il server imposta cookies (cf_clearance, __cfduid e altri) che confermano la legittimità del client. Una corretta gestione di questi cookies consente di evitare controlli ripetuti.

Estrazione e riutilizzo di cf_clearance

Il cookie cf_clearance è solitamente valido per 30-60 minuti. Dopo averlo ottenuto tramite un browser headless, può essere utilizzato in normali richieste 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):
        """Caricamento dei cookies salvati"""
        try:
            with open(self.cookie_file, 'rb') as f:
                data = pickle.load(f)
                # Verifica della scadenza
                if data['expires'] > datetime.now():
                    return data['cookies']
        except FileNotFoundError:
            pass
        return None
    
    def save_cookies(self, cookies, ttl_minutes=30):
        """Salvataggio dei cookies con 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):
        """Ottenimento di cf_clearance tramite browser"""
        if self.cookies:
            return self.cookies
        
        # Qui il codice per avviare il browser (dalla sezione precedente)
        # ...
        browser_cookies = bypass_cloudflare(url, proxy)['cookies']
        
        # Conversione in formato 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):
        """Richiesta con gestione automatica dei cookies"""
        cookies = self.get_cf_clearance(url, proxy)
        
        response = requests.get(
            url,
            cookies=cookies,
            proxies={'http': proxy, 'https': proxy},
            headers=get_random_headers()
        )
        
        # Se riceviamo di nuovo la sfida — aggiorniamo i cookies
        if response.status_code == 403 or 'cf-browser-verification' in response.text:
            print("Cookies scaduti, ottenimento di nuovi...")
            self.cookies = None
            return self.make_request(url, proxy)
        
        return response

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

Associazione dei cookies all'indirizzo IP

Cloudflare associa cf_clearance all'indirizzo IP da cui è stata superata la sfida. L'uso di questo cookie da un altro IP porterà a un blocco. Quando si lavora con proxy rotanti, è necessario conservare un set separato di cookies per ogni IP.

import hashlib

class IPBoundCookieManager:
    def __init__(self):
        self.cookies_by_ip = {}
    
    def get_ip_hash(self, proxy_url):
        """Creazione di un hash per identificare il proxy"""
        return hashlib.md5(proxy_url.encode()).hexdigest()
    
    def get_cookies_for_proxy(self, proxy_url, target_url):
        """Ottenimento di cookies per un proxy specifico"""
        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']
        
        # Ottenimento di nuovi cookies tramite 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

Rotazione dei proxy e controllo della frequenza delle richieste

Anche con la giusta tecnologia, una frequenza di richieste troppo alta da un singolo IP attiva il rate limiting. Cloudflare analizza i pattern di traffico e identifica attività anomale.

Strategie di rotazione dei proxy

Ci sono tre approcci principali alla rotazione: round-robin (sequenziale), random (casuale) e sticky sessions (associazione alla sessione). Per bypassare Cloudflare, la strategia ottimale è sticky sessions con limitazione delle richieste per 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
        
        # Contatori di utilizzo
        self.usage_count = defaultdict(int)
        self.last_used = {}
        self.cooldown_until = {}
    
    def get_proxy(self):
        """Ottenimento del prossimo proxy disponibile"""
        available_proxies = []
        
        for proxy in self.proxy_list:
            # Verifica del cooldown
            if proxy in self.cooldown_until:
                if datetime.now() < self.cooldown_until[proxy]:
                    continue
                else:
                    # Reset del contatore dopo il cooldown
                    self.usage_count[proxy] = 0
                    del self.cooldown_until[proxy]
            
            # Verifica del limite di richieste
            if self.usage_count[proxy] < self.max_requests_per_ip:
                available_proxies.append(proxy)
        
        if not available_proxies:
            # Se tutti i proxy sono in cooldown — aspetta
            wait_time = min(
                (self.cooldown_until[p] - datetime.now()).total_seconds()
                for p in self.cooldown_until
            )
            print(f"Tutti i proxy sono in cooldown. Attesa di {wait_time:.0f} secondi...")
            time.sleep(wait_time + 1)
            return self.get_proxy()
        
        # Selezione del proxy con il minor utilizzo
        proxy = min(available_proxies, key=lambda p: self.usage_count[p])
        
        self.usage_count[proxy] += 1
        self.last_used[proxy] = datetime.now()
        
        # Impostazione del cooldown al raggiungimento del limite
        if self.usage_count[proxy] >= self.max_requests_per_ip:
            self.cooldown_until[proxy] = datetime.now() + timedelta(
                minutes=self.cooldown_minutes
            )
            print(f"Il proxy {proxy} ha raggiunto il limite. Cooldown di {self.cooldown_minutes} minuti.")
        
        return proxy
    
    def add_delay(self):
        """Ritardo casuale tra le richieste (imitazione umana)"""
        delay = random.uniform(2, 5)  # 2-5 secondi
        time.sleep(delay)

# Utilizzo
proxy_pool = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
    # ... fino a 50-100 proxy per un funzionamento stabile
]

rotator = SmartProxyRotator(
    proxy_pool,
    max_requests_per_ip=15,  # Valore conservativo
    cooldown_minutes=15
)

# Esecuzione delle richieste
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"Richiesta {i+1}: {response.status_code}")
    rotator.add_delay()

Rate limiting adattivo

Un approccio più avanzato è l'adattamento dinamico della frequenza delle richieste in base alle risposte del server. Se iniziano a comparire errori 429 o captcha, riduci automaticamente il ritmo.

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):
        """Richiesta riuscita — si può accelerare"""
        self.success_streak += 1
        self.failure_streak = 0
        
        if self.success_streak >= 10:
            # Riduzione del ritardo del 10%
            self.delay = max(self.min_delay, self.delay * 0.9)
            self.success_streak = 0
    
    def on_failure(self, status_code):
        """Errore — rallentiamo"""
        self.failure_streak += 1
        self.success_streak = 0
        
        if status_code == 429:  # Rate limit
            # Rallentamento aggressivo
            self.delay = min(self.max_delay, self.delay * 2.0)
        elif status_code == 403:  # Possibile blocco
            self.delay = min(self.max_delay, self.delay * 1.5)
        
        print(f"Ritardo aumentato a {self.delay:.2f}s")
    
    def wait(self):
        """Attesa prima della prossima richiesta"""
        # Aggiungiamo casualità ±20%
        actual_delay = self.delay * random.uniform(0.8, 1.2)
        time.sleep(actual_delay)

Strumenti e librerie pronte all'uso per il bypass

Sviluppare una soluzione propria da zero richiede tempo e competenza. Esistono strumenti pronti che automatizzano il processo di bypass di Cloudflare.

cloudscraper (Python)

La libreria cloudscraper è un'estensione di requests che risolve automaticamente le sfide JavaScript. Funziona con le protezioni di base, ma potrebbe non affrontare controlli avanzati.

import cloudscraper

# Creazione di uno scraper con supporto proxy
scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

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

# Esecuzione della richiesta
response = scraper.get('https://example.com', proxies=proxies)

if response.status_code == 200:
    print("Bypass riuscito")
    print(response.text)
else:
    print(f"Errore: {response.status_code}")

FlareSolverr (universale)

FlareSolverr è un server proxy che avvia un browser headless per risolvere le sfide di Cloudflare. Funziona tramite API HTTP e supporta qualsiasi linguaggio di programmazione.

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

# Utilizzo da 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"Errore FlareSolverr: {result['message']}")

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

print(result['html'])

undetected-chromedriver

Versione patchata di Selenium ChromeDriver, che applica automaticamente molte tecniche anti-detect. Più semplice da usare rispetto a Playwright, ma meno flessibile.

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)
        
        # Attesa della scomparsa della sfida Cloudflare
        WebDriverWait(driver, 20).until_not(
            EC.presence_of_element_located((By.ID, "cf-spinner-please-wait"))
        )
        
        # Ulteriore attesa per affidabilità
        time.sleep(3)
        
        # Ottenimento del risultato
        html = driver.page_source
        cookies = driver.get_cookies()
        
        return {'html': html, 'cookies': cookies}
    
    finally:
        driver.quit()

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

Conclusione

Bypassare Cloudflare quando si utilizza un proxy richiede un approccio complesso: un corretto TLS fingerprint, header HTTP autentici, proxy di qualità e una gestione delle sessioni efficace. Raccomandazioni chiave:

• Utilizza proxy residenziali o proxy mobili invece di data center
• Applica librerie con un corretto TLS fingerprint (tls-client, curl-impersonate)
• Per casi complessi, utilizza browser headless con patch anti-detect
• Salva e riutilizza i cookies cf_clearance
• Ruota i proxy tenendo conto del rate limiting (non più di 15-20 richieste per IP)
• Aggiungi ritardi casuali tra le richieste (2-5 secondi)

La protezione di Cloudflare evolve costantemente, quindi è importante aggiornare regolarmente gli strumenti e adattare le strategie. Monitora le modifiche nelle tecniche di fingerprinting e testa le soluzioni sulle versioni attuali della protezione.

Per un funzionamento stabile, è consigliabile utilizzare servizi proxy professionali con un ampio pool di IP e rotazione automatica.