Wie man die Ban-Rate beim Web-Scraping auf 5% senkt: 12 bewährte Schutzmethoden

Wenn Sie Marktplätze scrapen, Konkurrenzpreise überwachen oder Daten von Websites sammeln, kennen Sie das Problem: Websites blockieren IP-Adressen, verlangen Captchas oder liefern leere Seiten zurück. Die Ban-Rate (Prozentsatz blockierter Anfragen) kann 70-90% erreichen, was das Scraping unmöglich macht. In diesem Artikel behandeln wir konkrete Methoden, die helfen, die Ban-Rate auf 5-10% zu senken und Daten stabil zu sammeln.

Wir betrachten sowohl technische Lösungen (Proxy-Rotation, HTTP-Header, Fingerprinting) als auch Verhaltensmuster (Verzögerungen, Nachahmung von Nutzeraktionen). Alle Methoden wurden in der Praxis beim Scraping von Wildberries, Ozon, Avito und ausländischen Plattformen getestet.

Warum Websites Scraper blockieren: Hauptauslöser

Bevor wir Schutzmethoden besprechen, ist es wichtig zu verstehen, wie Websites automatisierten Traffic erkennen. Moderne Anti-Bot-Systeme (Cloudflare, Akamai, DataDome, Imperva) analysieren Dutzende Parameter jeder Anfrage. Hier sind die Hauptauslöser für Blockierungen:

Beispielsweise beim Scraping von Wildberries ist ein typischer Fehler, Anfragen alle 0,5 Sekunden von einer IP zu senden. Das Cloudflare Anti-Bot-System erkennt das Muster sofort und blockiert die IP für 24 Stunden. Ein echter Nutzer verbringt 5-15 Sekunden mit der Betrachtung einer Produktkarte, scrollt die Seite, klickt auf Bilder.

Proxy-Rotation: Wie man IP-Adressen richtig wechselt

Die Verwendung von Proxys ist eine grundlegende Methode zur Senkung der Ban-Rate. Aber es ist wichtig, nicht nur Proxys zu kaufen, sondern die Rotation richtig zu konfigurieren. Hier sind bewährte Strategien:

Auswahl des Proxy-Typs für Scraping

Für das Scraping von Marktplätzen (Wildberries, Ozon, Avito) werden Residential Proxys empfohlen — sie haben IPs echter Heimnutzer, die schwer von normalem Traffic zu unterscheiden sind. Rechenzentrum-Proxys eignen sich für weniger geschützte Websites oder wenn maximale Geschwindigkeit bei großen Datenmengen erforderlich ist.

Strategien für IP-Rotation

Größe des Proxy-Pools

Die Mindestgröße des Pools hängt von der Scraping-Intensität ab:

• Niedrige Intensität (bis zu 10.000 Anfragen pro Tag): 10-20 Proxys
• Mittlere Intensität (10.000 - 100.000 Anfragen pro Tag): 50-100 Proxys
• Hohe Intensität (mehr als 100.000 Anfragen pro Tag): 200+ Proxys oder Residential mit automatischer Rotation

Für Residential Proxys mit Rotation bei jeder Anfrage (Rotating Proxys) kann die Pool-Größe kleiner sein, da der Anbieter automatisch eine neue IP aus seinem Pool von Millionen Adressen bereitstellt.

User-Agent und HTTP-Header: Nachahmung eines echten Browsers

Selbst mit guten Proxys können Sie blockiert werden, wenn HTTP-Header verdächtig aussehen. Websites analysieren nicht nur den User-Agent, sondern auch die Reihenfolge der Header, ihre Werte und die Übereinstimmung untereinander.

Korrekter User-Agent

Verwenden Sie nicht denselben User-Agent für alle Anfragen. Erstellen Sie eine Liste beliebter Browser und wählen Sie zufällig daraus:

user_agents = [
    # Chrome auf Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    # Chrome auf macOS
    "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",
    # Firefox auf Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    # Safari auf macOS
    "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",
    # Edge auf Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0"
]

Vollständiger Satz von HTTP-Headern

Moderne Browser senden 15-20 Header. Hier ist der minimal notwendige Satz zur Nachahmung von Chrome:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
    "Accept-Language": "de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7",
    "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",
    "Cache-Control": "max-age=0",
    "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"'
}

Beachten Sie die Header Sec-Fetch-* und sec-ch-ua-* — sie erschienen in neuen Chrome-Versionen und ihr Fehlen kann Automatisierung verraten.

Die Reihenfolge der Header ist wichtig

Browser senden Header in einer bestimmten Reihenfolge. Zum Beispiel setzt Chrome immer Host an erste Stelle, dann Connection, User-Agent usw. Wenn Sie die Python-Bibliothek requests verwenden, kann die Reihenfolge alphabetisch sein, was Automatisierung verrät.

Lösung: Verwenden Sie Bibliotheken, die Header korrekt formatieren (curl_cffi für Python, got für Node.js) oder Headless-Browser (Puppeteer, Playwright, Selenium), die Header wie ein echter Browser generieren.

Verzögerungen zwischen Anfragen: Optimale Intervalle

Eine der einfachsten, aber effektivsten Methoden zur Senkung der Ban-Rate sind korrekte Verzögerungen zwischen Anfragen. Ein echter Nutzer kann nicht 10 Seiten pro Sekunde öffnen, daher führen zu schnelle Anfragen sofort zur Blockierung.

Zufällige Verzögerungen statt fester

Verwenden Sie keine feste Verzögerung (z.B. genau 2 Sekunden zwischen Anfragen). Anti-Bot-Systeme erkennen solche Muster leicht. Verwenden Sie ein zufälliges Intervall:

import random
import time

# Statt fester Verzögerung
time.sleep(2)  # ❌ Schlecht

# Verwenden Sie ein zufälliges Intervall
delay = random.uniform(2.5, 5.5)  # ✅ Gut
time.sleep(delay)

Empfohlene Intervalle für verschiedene Websites

Adaptive Verzögerungen basierend auf Server-Antworten

Ein fortgeschrittener Ansatz — Verzögerungen dynamisch basierend auf Server-Antworten ändern:

base_delay = 3.0  # Basisverzögerung
delay_multiplier = 1.0

response = requests.get(url, headers=headers, proxies=proxies)

# Wenn Captcha oder 429 erhalten — Verzögerung erhöhen
if response.status_code == 429 or 'captcha' in response.text.lower():
    delay_multiplier *= 1.5
    print(f"Schutz erkannt, Verzögerung auf {base_delay * delay_multiplier}s erhöht")

# Wenn alles gut ist — können etwas beschleunigen
elif response.status_code == 200:
    delay_multiplier = max(1.0, delay_multiplier * 0.95)

time.sleep(random.uniform(base_delay * delay_multiplier, base_delay * delay_multiplier * 1.5))

Dieser Ansatz ermöglicht es, automatisch zu verlangsamen, wenn Schutz erkannt wird, und zu beschleunigen, wenn die Website keine Aggression zeigt.

Schutz vor Fingerprinting: Canvas, WebGL, Schriftarten

Wenn die Website JavaScript zur Überprüfung verwendet, reichen einfache HTTP-Header nicht aus. Moderne Anti-Bot-Systeme erstellen einen Browser-"Fingerabdruck" basierend auf Dutzenden von Parametern: Canvas, WebGL, installierten Schriftarten, Zeitzone, Bildschirmauflösung und anderen.

Hauptparameter des Fingerprinting

Tools zur Umgehung von Fingerprinting

Zur Umgehung von Fingerprinting verwenden Sie spezialisierte Tools:

• Undetected ChromeDriver (Python) — modifizierte Version von Selenium, die Automatisierungsmerkmale verbirgt
• Puppeteer Stealth (Node.js) — Plugin für Puppeteer, das Fingerprint-Parameter ersetzt
• Playwright mit Stealth — ähnlich wie Puppeteer, aber mit besserer Unterstützung verschiedener Browser
• Anti-Detect-Browser (Dolphin Anty, AdsPower, Multilogin) — für diejenigen, die keinen Code schreiben möchten, ersetzen diese Browser automatisch den Fingerprint

Beispiel für die Verwendung von undetected-chromedriver in Python:

import undetected_chromedriver as uc

# Browser mit Erkennungsschutz erstellen
options = uc.ChromeOptions()
options.add_argument('--disable-blink-features=AutomationControlled')

driver = uc.Chrome(options=options)
driver.get('https://example.com')

# Prüfen, dass navigator.webdriver === undefined
webdriver_status = driver.execute_script("return navigator.webdriver")
print(f"navigator.webdriver: {webdriver_status}")  # Sollte None/undefined sein

Verwaltung von Cookies und Sessions

Viele Websites verwenden Cookies zur Verfolgung des Nutzerverhaltens. Die richtige Verwaltung von Cookies hilft, Blockierungen zu vermeiden und wie ein echter Nutzer auszusehen.

Speichern und Wiederverwenden von Cookies

Statt bei jeder Anfrage eine neue Session zu erstellen, speichern Sie Cookies und verwenden Sie sie wiederholt. Dies ahmt das Verhalten eines echten Nutzers nach, der zur Website zurückkehrt:

import requests
import pickle

session = requests.Session()

# Erster Besuch — Cookies erhalten
response = session.get('https://example.com')

# Cookies in Datei speichern
with open('cookies.pkl', 'wb') as f:
    pickle.dump(session.cookies, f)

# Später Cookies laden
with open('cookies.pkl', 'rb') as f:
    session.cookies.update(pickle.load(f))

# Jetzt sehen Anfragen wie von einem zurückkehrenden Nutzer aus
response = session.get('https://example.com/catalog')

Session-Aufwärmung vor dem Scraping

Beginnen Sie das Scraping nicht sofort mit Zielseiten. Ahmen Sie das Verhalten eines echten Nutzers nach:

1. Öffnen Sie die Startseite der Website
2. Warten Sie 2-5 Sekunden
3. Öffnen Sie eine Kategorie- oder Bereichsseite
4. Warten Sie 3-7 Sekunden
5. Erst danach beginnen Sie mit dem Scraping der Zielseiten

Dies erstellt eine Aktivitätshistorie in Cookies und reduziert die Wahrscheinlichkeit einer Blockierung.

Verarbeitung von Session-Cookies und Tokens

Einige Websites generieren beim ersten Besuch eindeutige Tokens und prüfen sie bei nachfolgenden Anfragen. Zum Beispiel verwendet Wildberries ein Token im Header x-requested-with. Speichern Sie solche Tokens immer aus der ersten Antwort und senden Sie sie in nachfolgenden Anfragen.

JavaScript-Rendering: Wann es notwendig ist

Viele moderne Websites laden Inhalte über JavaScript. Wenn Sie einen einfachen HTTP-Client verwenden (requests in Python, axios in Node.js), erhalten Sie eine leere Seite oder einen Platzhalter. In solchen Fällen ist JavaScript-Rendering erforderlich.

Wann JavaScript-Rendering erforderlich ist

• Website verwendet React, Vue, Angular — Inhalte werden nach dem ersten Laden der Seite geladen
• Daten werden über AJAX/Fetch-Anfragen nachgeladen
• Website erfordert JavaScript-Ausführung zur Generierung von Tokens oder Cookies
• Bot-Schutz vorhanden, der JS-Code-Ausführung erfordert (z.B. Cloudflare Challenge)

Tools für JavaScript-Rendering

Für die meisten Aufgaben wird Playwright empfohlen — es ist schneller als Selenium, umgeht Schutz besser und hat eine komfortablere API.

Alternative: Abfangen von API-Anfragen

Oft kann JavaScript-Rendering vermieden werden, wenn Sie die API-Anfragen finden, die die Website zum Laden von Daten verwendet. Öffnen Sie DevTools (F12) → Registerkarte Network → Filter XHR/Fetch und sehen Sie, welche Anfragen die Website sendet. Wiederholen Sie dann diese Anfragen direkt über einen HTTP-Client.

Beispiel: Wildberries lädt Produktdaten über die API https://catalog.wb.ru/catalog/.... Statt die gesamte Seite zu rendern, können Sie diese API direkt abfragen, was 10-20 Mal schneller ist.

Captcha-Umgehung: Automatische Lösungen

Selbst mit korrekten Proxys und Headern können Sie auf Captchas stoßen. Es gibt mehrere Ansätze zu ihrer Lösung:

Captcha-Typen und Lösungsmethoden

Integration eines Captcha-Erkennungsdienstes

Beispiel für die Integration von 2Captcha in Python:

from twocaptcha import TwoCaptcha

solver = TwoCaptcha('YOUR_API_KEY')

try:
    # reCAPTCHA v2 lösen
    result = solver.recaptcha(
        sitekey='6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
        url='https://example.com'
    )
    
    # Lösungs-Token erhalten
    captcha_token = result['code']
    
    # Formular mit Token senden
    response = requests.post('https://example.com/submit', data={
        'g-recaptcha-response': captcha_token
    })
    
except Exception as e:
    print(f"Captcha-Lösungsfehler: {e}")

Rate Limiting: Wie man Website-Limits nicht überschreitet

Viele Websites haben explizite oder implizite Limits für die Anzahl der Anfragen. Das Überschreiten dieser Limits führt zu temporärer oder permanenter IP-Blockierung.

Bestimmung der Website-Limits

Achten Sie auf HTTP-Header in Server-Antworten:

• X-RateLimit-Limit — maximale Anzahl von Anfragen im Zeitraum
• X-RateLimit-Remaining — wie viele Anfragen übrig sind
• X-RateLimit-Reset — wann das Limit zurückgesetzt wird (Unix-Zeitstempel)
• Retry-After — nach wie vielen Sekunden die Anfrage wiederholt werden kann

Wenn Sie den Statuscode 429 (Too Many Requests) erhalten, bedeutet dies eine Limit-Überschreitung. Lesen Sie den Header Retry-After und warten Sie die angegebene Zeit vor der nächsten Anfrage.

Implementierung eines Rate Limiters

Erstellen Sie einen Mechanismus zur Kontrolle der Anfragengeschwindigkeit:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests, time_window):
        self.max_requests = max_requests  # Maximale Anfragen
        self.time_window = time_window    # Zeitfenster in Sekunden
        self.requests = deque()
    
    def wait_if_needed(self):
        now = time.time()
        
        # Alte Anfragen entfernen
        while self.requests and self.requests[0] < now - self.time_window:
            self.requests.popleft()
        
        # Wenn Limit erreicht — warten
        if len(self.requests) >= self.max_requests:
            sleep_time = self.time_window - (now - self.requests[0])
            if sleep_time > 0:
                print(f"Rate Limit erreicht, warte {sleep_time:.2f}s")
                time.sleep(sleep_time)
                self.requests.popleft()
        
        # Aktuelle Anfrage hinzufügen
        self.requests.append(time.time())

# Verwendung: maximal 100 Anfragen pro Minute
limiter = RateLimiter(max_requests=100, time_window=60)

for url in urls:
    limiter.wait_if_needed()
    response = requests.get(url)

Überwachung von Metriken: Ban-Rate verfolgen

Um die Effektivität Ihrer Anti-Ban-Strategien zu bewerten, ist es wichtig, Metriken zu überwachen. Hier sind die wichtigsten Indikatoren:

Wichtige Metriken für Scraping

• Ban Rate — Prozentsatz blockierter Anfragen (Ziel: unter 10%)
• Success Rate — Prozentsatz erfolgreicher Anfragen mit gültigen Daten (Ziel: über 90%)
• Captcha Rate — Prozentsatz der Anfragen, die Captcha erhalten (Ziel: unter 5%)
• Average Response Time — durchschnittliche Antwortzeit (hilft, langsame Proxys zu erkennen)
• Proxy Health — Prozentsatz funktionierender Proxys im Pool

Implementierung der Metrikenerfassung

class ScrapingMetrics:
    def __init__(self):
        self.total_requests = 0
        self.successful_requests = 0
        self.blocked_requests = 0
        self.captcha_requests = 0
        self.response_times = []
    
    def record_request(self, success, blocked=False, captcha=False, response_time=0):
        self.total_requests += 1
        if success:
            self.successful_requests += 1
        if blocked:
            self.blocked_requests += 1
        if captcha:
            self.captcha_requests += 1
        if response_time > 0:
            self.response_times.append(response_time)
    
    def get_stats(self):
        if self.total_requests == 0:
            return "Keine Anfragen"
        
        ban_rate = (self.blocked_requests / self.total_requests) * 100
        success_rate = (self.successful_requests / self.total_requests) * 100
        captcha_rate = (self.captcha_requests / self.total_requests) * 100
        avg_response_time = sum(self.response_times) / len(self.response_times) if self.response_times else 0
        
        return f"""
        Gesamt-Anfragen: {self.total_requests}
        Success Rate: {success_rate:.2f}%
        Ban Rate: {ban_rate:.2f}%
        Captcha Rate: {captcha_rate:.2f}%
        Durchschn. Antwortzeit: {avg_response_time:.2f}s
        """

# Verwendung
metrics = ScrapingMetrics()

for url in urls:
    start_time = time.time()
    try:
        response = requests.get(url, proxies=proxy, headers=headers)
        response_time = time.time() - start_time
        
        if response.status_code == 200:
            if 'captcha' in response.text.lower():
                metrics.record_request(success=False, captcha=True, response_time=response_time)
            else:
                metrics.record_request(success=True, response_time=response_time)
        elif response.status_code in [403, 429]:
            metrics.record_request(success=False, blocked=True, response_time=response_time)
    except Exception as e:
        metrics.record_request(success=False, blocked=True)

print(metrics.get_stats())

Vergleich von Scraping-Tools

Die Wahl des richtigen Tools kann die Ban-Rate erheblich beeinflussen. Hier ist ein Vergleich beliebter Lösungen:

Fazit

Die Senkung der Ban-Rate beim Web-Scraping erfordert einen umfassenden Ansatz. Hier ist eine Checkliste der wichtigsten Maßnahmen:

Denken Sie daran: Das Ziel ist nicht, die Website zu täuschen, sondern legitimen automatisierten Zugriff zu organisieren, der sich minimal von echtem Nutzerverhalten unterscheidet. Beginnen Sie mit einfachen Methoden (Proxys + Verzögerungen) und fügen Sie bei Bedarf komplexere Schutzmechanismen hinzu.

Wenn Sie qualitativ hochwertige Proxys für Scraping benötigen, schauen Sie sich ProxyCove an — wir bieten Residential, Mobile und Rechenzentrum-Proxys mit niedriger Ban-Rate und technischem Support.