7 bewährte Methoden zur Umgehung der Cloudflare-Erkennung bei der Verwendung von Proxys

Cloudflare verarbeitet mehr als 20% des gesamten Webverkehrs und verwendet ein mehrschichtiges Bot-Schutzsystem. Bei der Verwendung von Proxy-Servern steigt die Wahrscheinlichkeit, eine CAPTCHA oder Sperrung zu erhalten, erheblich. In diesem Leitfaden werden wir die technischen Aspekte der Erkennung und praktische Umgehungsmethoden untersuchen, die im Jahr 2024 funktionieren.

Wie Cloudflare Proxys und Bots erkennt

Cloudflare verwendet ein umfassendes Analyse-System, das Dutzende von Parametern jeder Anfrage überprüft. Das Verständnis der Erkennungsmechanismen ist der erste Schritt zur erfolgreichen Umgehung des Schutzes.

Hauptmethoden der Erkennung

Bei der Analyse der Anfrage vergleicht Cloudflare den TLS-Fingerabdruck mit dem angegebenen User-Agent. Wenn Sie Chrome 120 angeben, die TLS-Parameter jedoch zu Python requests passen, ist dies eine sofortige Erkennung des Bots.

Seit 2023 verwendet Cloudflare aktiv maschinelles Lernen zur Analyse von Verhaltensmustern. Das System verfolgt nicht nur technische Parameter, sondern auch die Zeitintervalle zwischen Anfragen, die Reihenfolge der Benutzeraktionen, Mausbewegungen und das Scrollen der Seite.

Maskierung des TLS-Fingerabdrucks

TLS-Fingerprinting ist die effektivste Methode zur Erkennung von Bots. Standard-HTTP-Clients (requests, curl, axios) erzeugen einen Fingerabdruck, der nicht mit einem echten Browser verwechselt werden kann. Die Lösung besteht darin, spezialisierte Bibliotheken zu verwenden, die das TLS-Verhalten von Browsern nachahmen.

Verwendung von curl-impersonate

Die Bibliothek curl-impersonate ist eine modifizierte Version von curl, die die TLS- und HTTP/2-Fingerabdrücke beliebter Browser genau kopiert. Sie unterstützt Chrome, Firefox, Safari und Edge.

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

# Verwendung mit der Nachahmung von 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: Bibliothek tls-client

Für Python gibt es eine Wrapper-Bibliothek tls-client, die curl-impersonate im Hintergrund verwendet und eine ähnliche Schnittstelle wie requests bietet.

import tls_client

# Erstellung einer Sitzung mit dem Fingerabdruck von Chrome 120
session = tls_client.Session(
    client_identifier="chrome_120",
    random_tls_extension_order=True
)

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

# Ausführung der Anfrage
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)

Überprüfung des TLS-Fingerabdrucks

Vor dem Parsen wird empfohlen, Ihren TLS-Fingerabdruck zu überprüfen. Verwenden Sie Dienste wie tls.peet.ws oder ja3er.com zur Analyse.

# Überprüfung des Fingerabdrucks
response = session.get('https://tls.peet.ws/api/all')
print(response.json()['tls']['ja3'])

# Vergleichen Sie mit dem Fingerabdruck eines echten Chrome:
# https://kawayiyi.com/tls-fingerprint-database/

Richtige Konfiguration der HTTP-Header

Selbst mit dem richtigen TLS-Fingerabdruck werden falsche HTTP-Header einen Bot verraten. Cloudflare analysiert nicht nur das Vorhandensein von Headern, sondern auch deren Reihenfolge, Format der Werte und logische Konsistenz.

Obligatorische Header für 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'
}

Die Header Sec-Ch-Ua-* wurden in Chrome 89 eingeführt und sind Teil der Client Hints API. Ihr Fehlen bei der Verwendung eines modernen User-Agent ist ein offensichtliches Zeichen für einen Bot.

Die Reihenfolge der Header ist wichtig

In HTTP/2 ist die Reihenfolge der Header für jeden Browser festgelegt. Python requests und andere Standard-Clients senden Header in alphabetischer Reihenfolge, was sich vom Verhalten der Browser unterscheidet. Verwenden Sie Bibliotheken, die benutzerdefinierte Header-Reihenfolgen unterstützen.

Dynamische Generierung des User-Agent

Die Verwendung desselben User-Agent für alle Anfragen erhöht das Risiko der Erkennung. Erstellen Sie einen Pool aktueller User-Agents und rotieren Sie diese.

import random

# Pool aktueller User-Agents (Dezember 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)
    
    # Anpassung anderer Header an den gewählten UA
    if 'Chrome' in ua:
        return {
            'User-Agent': ua,
            'Sec-Ch-Ua': '"Not_A Brand";v="8", "Chromium";v="120"',
            # ... andere Chrome-Header
        }
    elif 'Firefox' in ua:
        return {
            'User-Agent': ua,
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            # ... Firefox-Header
        }
    # ... Verarbeitung anderer Browser

Verwendung von Headless-Browsern

Wenn Cloudflare eine JavaScript-Herausforderung oder fortschrittliche Erkennung verwendet, ist der einzige zuverlässige Weg zur Umgehung ein echter Browser. Headless-Browser verarbeiten automatisch JavaScript, Cookies und erstellen einen vollständig authentischen Fingerabdruck.

Playwright mit Anti-Detect-Patches

Playwright ist eine moderne Alternative zu Selenium mit besserer Leistung. Der Standard-Playwright wird jedoch leicht über navigator.webdriver und andere Marker erkannt. Verwenden Sie playwright-stealth zur Maskierung.

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)  # Anwendung von Anti-Detect-Patches
        
        # Wechsel zur Seite
        page.goto(url, wait_until='networkidle', timeout=30000)
        
        # Warten auf das Bestehen der Cloudflare-Herausforderung (normalerweise 5-10 Sekunden)
        page.wait_for_timeout(8000)
        
        # Überprüfung des erfolgreichen Umgehens
        if 'Just a moment' in page.content():
            print('Cloudflare-Herausforderung nicht bestanden')
            return None
        
        # Extrahieren von Cookies zur späteren Verwendung
        cookies = context.cookies()
        html = page.content()
        
        browser.close()
        return {'html': html, 'cookies': cookies}

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

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

Puppeteer Extra mit Plugins

Für das Node.js-Ökosystem ist die beste Lösung puppeteer-extra mit dem Plugin puppeteer-extra-plugin-stealth. Dieses Plugin wendet über 30 verschiedene Techniken zur Maskierung der Automatisierung an.

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();
    
    // Festlegung von Viewport und User-Agent
    await page.setViewport({ width: 1920, height: 1080 });
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
    
    // Überschreibung von navigator.webdriver
    await page.evaluateOnNewDocument(() => {
        delete Object.getPrototypeOf(navigator).webdriver;
    });
    
    // Wechsel zur Seite
    await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
    
    // Warten auf das Bestehen der Herausforderung
    await page.waitForTimeout(8000);
    
    // Abrufen des Inhalts und der Cookies
    const content = await page.content();
    const cookies = await page.cookies();
    
    await browser.close();
    
    return { content, cookies };
}

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

Auswahl des Proxy-Typs zur Umgehung von Cloudflare

Der Typ des Proxys hat einen entscheidenden Einfluss auf den Erfolg der Umgehung. Cloudflare führt Datenbanken mit IP-Adressen von Rechenzentren und wendet strengere Prüfregeln darauf an.

Warum Residential-Proxys effektiver sind

Residential-Proxys verwenden IP-Adressen realer Geräte (Heimrouter, Smartphones). Cloudflare kann solche IPs nicht massenhaft blockieren, da dies normale Benutzer blockieren würde. Statistiken zeigen, dass Residential-IPs 15-20 Mal seltener ein CAPTCHA erhalten als Rechenzentren.

Bei der Verwendung von Residential-Proxys ist die Geolokalisierung entscheidend. Wenn die Zielseite auf die USA ausgerichtet ist, erhöht die Verwendung von Proxys aus Asien die Verdächtigkeit. Wählen Sie Anbieter mit breiter geografischer Abdeckung und der Möglichkeit, nach Städten zu zielen.

Mobile Proxys für maximale Zuverlässigkeit

Mobile Proxys verwenden IP-Adressen von Mobilfunkanbietern (4G/5G). Eine Besonderheit mobiler Netzwerke ist der dynamische IP-Wechsel über den Flugmodus, was eine praktisch unbegrenzte Anzahl von sauberen IP-Adressen ermöglicht. Die Wahrscheinlichkeit, dass eine mobile IP blockiert wird, ist nahezu null.

# Beispiel für die Rotation einer mobilen IP über API
import requests
import time

def rotate_mobile_ip(proxy_api_url):
    """Ändern der IP eines mobilen Proxys"""
    response = requests.get(f"{proxy_api_url}/rotate")
    if response.status_code == 200:
        print("IP erfolgreich geändert")
        time.sleep(5)  # Warten auf die Anwendung der Änderungen
        return True
    return False

# Verwendung mit mobilem Proxy
mobile_proxy = "http://user:pass@mobile.proxy.com:8080"

for i in range(10):
    # Ausführung der Anfrage
    response = requests.get(
        'https://example.com',
        proxies={'http': mobile_proxy, 'https': mobile_proxy}
    )
    
    # Rotation der IP nach jeder Anfrage
    rotate_mobile_ip('https://api.proxy.com/mobile')

Verwaltung von Cookies und Sitzungen

Nach dem erfolgreichen Bestehen der Cloudflare-Herausforderung setzt der Server Cookies (cf_clearance, __cfduid und andere), die die Legitimität des Clients bestätigen. Die richtige Verwaltung dieser Cookies ermöglicht es, wiederholte Prüfungen zu vermeiden.

Extraktion und Wiederverwendung von cf_clearance

Das Cookie cf_clearance ist normalerweise 30-60 Minuten gültig. Nach dem Erhalt über einen Headless-Browser kann es in normalen HTTP-Anfragen verwendet werden.

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):
        """Laden der gespeicherten Cookies"""
        try:
            with open(self.cookie_file, 'rb') as f:
                data = pickle.load(f)
                # Überprüfung des Verfallsdatums
                if data['expires'] > datetime.now():
                    return data['cookies']
        except FileNotFoundError:
            pass
        return None
    
    def save_cookies(self, cookies, ttl_minutes=30):
        """Speichern von Cookies mit 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):
        """Erhalten von cf_clearance über den Browser"""
        if self.cookies:
            return self.cookies
        
        # Hier der Code zum Starten des Browsers (aus dem vorherigen Abschnitt)
        # ...
        browser_cookies = bypass_cloudflare(url, proxy)['cookies']
        
        # Konvertierung in das Format von 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):
        """Anfrage mit automatischer Verwaltung von Cookies"""
        cookies = self.get_cf_clearance(url, proxy)
        
        response = requests.get(
            url,
            cookies=cookies,
            proxies={'http': proxy, 'https': proxy},
            headers=get_random_headers()
        )
        
        # Wenn eine Herausforderung erneut auftritt — Cookies aktualisieren
        if response.status_code == 403 or 'cf-browser-verification' in response.text:
            print("Cookies sind abgelaufen, neue werden abgerufen...")
            self.cookies = None
            return self.make_request(url, proxy)
        
        return response

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

Bindung von Cookies an die IP-Adresse

Cloudflare bindet cf_clearance an die IP-Adresse, von der die Herausforderung bestanden wurde. Die Verwendung dieses Cookies von einer anderen IP führt zur Blockierung. Bei der Verwendung von rotierenden Proxys ist es notwendig, einen separaten Satz von Cookies für jede IP zu speichern.

import hashlib

class IPBoundCookieManager:
    def __init__(self):
        self.cookies_by_ip = {}
    
    def get_ip_hash(self, proxy_url):
        """Erstellung eines Hashs zur Identifizierung des Proxys"""
        return hashlib.md5(proxy_url.encode()).hexdigest()
    
    def get_cookies_for_proxy(self, proxy_url, target_url):
        """Erhalten von Cookies für einen bestimmten Proxy"""
        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']
        
        # Abrufen neuer Cookies über den 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

Rotation von Proxys und Kontrolle der Anfragerate

Selbst mit dem richtigen technischen Stack löst eine zu hohe Anfragerate von einer IP die Rate-Limiting-Funktion aus. Cloudflare analysiert die Verkehrsmuster und erkennt anomale Aktivitäten.

Strategien zur Proxy-Rotation

Es gibt drei Hauptansätze zur Rotation: Round-Robin (sequentiell), Random (zufällig) und Sticky Sessions (Bindung an die Sitzung). Für die Umgehung von Cloudflare ist die Strategie der Sticky Sessions mit einer Begrenzung der Anfragen pro IP 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
        
        # Nutzungszähler
        self.usage_count = defaultdict(int)
        self.last_used = {}
        self.cooldown_until = {}
    
    def get_proxy(self):
        """Erhalten des nächsten verfügbaren Proxys"""
        available_proxies = []
        
        for proxy in self.proxy_list:
            # Überprüfung des Cooldowns
            if proxy in self.cooldown_until:
                if datetime.now() < self.cooldown_until[proxy]:
                    continue
                else:
                    # Zurücksetzen des Zählers nach dem Cooldown
                    self.usage_count[proxy] = 0
                    del self.cooldown_until[proxy]
            
            # Überprüfung des Anfrage-Limits
            if self.usage_count[proxy] < self.max_requests_per_ip:
                available_proxies.append(proxy)
        
        if not available_proxies:
            # Wenn alle Proxys im Cooldown sind — warten
            wait_time = min(
                (self.cooldown_until[p] - datetime.now()).total_seconds()
                for p in self.cooldown_until
            )
            print(f"Alle Proxys im Cooldown. Wartezeit {wait_time:.0f} Sekunden...")
            time.sleep(wait_time + 1)
            return self.get_proxy()
        
        # Auswahl des Proxys mit der geringsten Nutzung
        proxy = min(available_proxies, key=lambda p: self.usage_count[p])
        
        self.usage_count[proxy] += 1
        self.last_used[proxy] = datetime.now()
        
        # Festlegung des Cooldowns bei Erreichen des Limits
        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} hat das Limit erreicht. Cooldown von {self.cooldown_minutes} Minuten.")
        
        return proxy
    
    def add_delay(self):
        """Zufällige Verzögerung zwischen Anfragen (Nachahmung eines Menschen)"""
        delay = random.uniform(2, 5)  # 2-5 Sekunden
        time.sleep(delay)

# Verwendung
proxy_pool = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
    # ... bis zu 50-100 Proxys für stabilen Betrieb
]

rotator = SmartProxyRotator(
    proxy_pool,
    max_requests_per_ip=15,  # Konservativer Wert
    cooldown_minutes=15
)

# Ausführung von Anfragen
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"Anfrage {i+1}: {response.status_code}")
    rotator.add_delay()

Adaptives Rate Limiting

Ein fortschrittlicherer Ansatz ist die dynamische Anpassung der Anfragerate basierend auf den Serverantworten. Wenn 429-Fehler oder CAPTCHAs auftreten, reduzieren wir automatisch das 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):
        """Erfolgreiche Anfrage — Tempo erhöhen"""
        self.success_streak += 1
        self.failure_streak = 0
        
        if self.success_streak >= 10:
            # Verzögerung um 10% reduzieren
            self.delay = max(self.min_delay, self.delay * 0.9)
            self.success_streak = 0
    
    def on_failure(self, status_code):
        """Fehler — langsamer werden"""
        self.failure_streak += 1
        self.success_streak = 0
        
        if status_code == 429:  # Rate-Limit
            # Aggressive Verlangsamung
            self.delay = min(self.max_delay, self.delay * 2.0)
        elif status_code == 403:  # Mögliche Blockierung
            self.delay = min(self.max_delay, self.delay * 1.5)
        
        print(f"Verzögerung erhöht auf {self.delay:.2f}s")
    
    def wait(self):
        """Warten vor der nächsten Anfrage"""
        # Zufälligkeit ±20% hinzufügen
        actual_delay = self.delay * random.uniform(0.8, 1.2)
        time.sleep(actual_delay)

Fertige Tools und Bibliotheken zur Umgehung

Die Entwicklung einer eigenen Lösung von Grund auf erfordert Zeit und Expertise. Es gibt fertige Tools, die den Prozess der Umgehung von Cloudflare automatisieren.

cloudscraper (Python)

Die Bibliothek cloudscraper ist eine Erweiterung von requests, die automatisch JavaScript-Herausforderungen löst. Sie funktioniert mit grundlegenden Schutzmaßnahmen, kann jedoch bei fortgeschrittenen Prüfungen versagen.

import cloudscraper

# Erstellung eines Scrapers mit Proxy-Unterstützung
scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

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

# Ausführung der Anfrage
response = scraper.get('https://example.com', proxies=proxies)

if response.status_code == 200:
    print("Erfolgreiche Umgehung")
    print(response.text)
else:
    print(f"Fehler: {response.status_code}")

FlareSolverr (universell)

FlareSolverr ist ein Proxy-Server, der einen Headless-Browser zum Lösen von Cloudflare-Herausforderungen startet. Er funktioniert über eine HTTP-API und unterstützt alle Programmiersprachen.

# Start von FlareSolverr über Docker
docker run -d \
  --name=flaresolverr \
  -p 8191:8191 \
  -e LOG_LEVEL=info \
  ghcr.io/flaresolverr/flaresolverr:latest

# Verwendung aus Python
import requests

def solve_cloudflare(url, proxy=None):
    flaresolverr_url = "http://localhost:8191/v1"
    
    payload = {
        "cmd": "request.get",
        "url": url,
        "maxTimeout": 60000
    }
    
    if proxy:
        payload["proxy"] = {
            "url": proxy
        }
    
    response = requests.post(flaresolverr_url, json=payload)
    result = response.json()
    
    if result['status'] == 'ok':
        return {
            'html': result['solution']['response'],
            'cookies': result['solution']['cookies'],
            'user_agent': result['solution']['userAgent']
        }
    else:
        raise Exception(f"FlareSolverr-Fehler: {result['message']}")

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

print(result['html'])

undetected-chromedriver

Eine gepatchte Version des Selenium ChromeDrivers, die automatisch viele Anti-Detect-Techniken anwendet. Einfacher zu verwenden als Playwright, aber weniger flexibel.

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)
        
        # Warten auf das Verschwinden der Cloudflare-Herausforderung
        WebDriverWait(driver, 20).until_not(
            EC.presence_of_element_located((By.ID, "cf-spinner-please-wait"))
        )
        
        # Zusätzliche Wartezeit für Zuverlässigkeit
        time.sleep(3)
        
        # Abrufen des Ergebnisses
        html = driver.page_source
        cookies = driver.get_cookies()
        
        return {'html': html, 'cookies': cookies}
    
    finally:
        driver.quit()

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

Fazit

Die Umgehung von Cloudflare bei der Verwendung von Proxys erfordert einen umfassenden Ansatz: den richtigen TLS-Fingerabdruck, authentische HTTP-Header, qualitativ hochwertige Proxys und eine kluge Verwaltung von Sitzungen. Wichtige Empfehlungen:

• Verwenden Sie Residential oder mobile Proxys anstelle von Rechenzentren
• Wenden Sie Bibliotheken mit dem richtigen TLS-Fingerabdruck an (tls-client, curl-impersonate)
• Für komplexe Fälle verwenden Sie Headless-Browser mit Anti-Detect-Patches
• Speichern und wiederverwenden Sie cf_clearance-Cookies
• Rotieren Sie Proxys unter Berücksichtigung des Rate Limitings (nicht mehr als 15-20 Anfragen pro IP)
• Fügen Sie zufällige Verzögerungen zwischen den Anfragen hinzu (2-5 Sekunden)

Der Schutz von Cloudflare entwickelt sich ständig weiter, daher ist es wichtig, die Tools regelmäßig zu aktualisieren und die Strategien anzupassen. Überwachen Sie Änderungen in den Fingerprinting-Techniken und testen Sie Lösungen mit aktuellen Schutzversionen.

Für einen stabilen Betrieb wird empfohlen, professionelle Proxy-Dienste mit einem breiten Pool von IPs und automatischer Rotation zu verwenden.