Schutz vor Sperren bei Massenanfragen: Techniken und Werkzeuge

Die Sperrung von Konten und IP-Adressen ist das Hauptproblem beim Scraping, der Automatisierung und bei Massenoperationen in sozialen Netzwerken. Moderne Anti-Bot-Systeme analysieren Dutzende von Parametern: von der Anfragerate bis zu Browser-Fingerabdrücken. In diesem Leitfaden werden wir spezifische Mechanismen zur Erkennung von Automatisierung und praktische Möglichkeiten zu deren Umgehung untersuchen.

Mechanismen zur Erkennung von Automatisierung

Moderne Schutzsysteme verwenden eine mehrstufige Analyse zur Identifizierung von Bots. Das Verständnis dieser Mechanismen ist entscheidend für die Wahl der richtigen Umgehungsstrategie.

Hauptanalyseparameter

Anfragerate (Request Rate): Ein Mensch kann physisch nicht 100 Anfragen pro Minute senden. Systeme analysieren nicht nur die Gesamtzahl, sondern auch die zeitliche Verteilung — gleichmäßige Intervalle zwischen Anfragen verraten einen Bot.

Verhaltensmuster: Abfolgen von Aktionen, Scrolltiefe, Mausbewegungen, Zeit auf der Seite. Ein Bot, der sofort ohne Verzögerung auf Links klickt, wird leicht erkannt.

Technische Fingerabdrücke: User-Agent, HTTP-Header, Reihenfolge der Header, TLS-Fingerabdruck, Canvas/WebGL-Fingerprinting. Abweichungen in diesen Parametern sind ein rotes Signal für Anti-Bot-Systeme.

Ratenbegrenzung und Kontrolle der Anfragerate

Die Kontrolle der Anfragerate ist die erste Verteidigungslinie gegen Sperren. Selbst mit Proxy-Rotation führt ein zu aggressives Scraping zu einem Bann.

Dynamische Verzögerungen

Feste Intervalle (z.B. genau 2 Sekunden zwischen Anfragen) sind leicht zu erkennen. Verwenden Sie zufällige Verzögerungen mit normaler Verteilung:

import time
import random
import numpy as np

def human_delay(min_delay=1.5, max_delay=4.0, mean=2.5, std=0.8):
    """
    Generierung einer Verzögerung mit normaler Verteilung,
    die menschliches Verhalten imitiert
    """
    delay = np.random.normal(mean, std)
    # Begrenzung des Bereichs
    delay = max(min_delay, min(delay, max_delay))
    
    # Hinzufügen von Mikrozögerungen für Realismus
    delay += random.uniform(0, 0.3)
    
    time.sleep(delay)

# Verwendung
for url in urls:
    response = session.get(url)
    human_delay(min_delay=2, max_delay=5, mean=3, std=1)

Anpassbare Ratenbegrenzung

Ein fortschrittlicherer Ansatz ist die Anpassung der Geschwindigkeit basierend auf den Antworten des Servers. Wenn Sie Codes 429 (Too Many Requests) oder 503 erhalten, reduzieren Sie automatisch das Tempo:

class AdaptiveRateLimiter:
    def __init__(self, initial_delay=2.0):
        self.current_delay = initial_delay
        self.min_delay = 1.0
        self.max_delay = 30.0
        self.error_count = 0
        
    def wait(self):
        time.sleep(self.current_delay + random.uniform(0, 0.5))
        
    def on_success(self):
        # Allmähliche Beschleunigung bei erfolgreichen Anfragen
        self.current_delay = max(
            self.min_delay, 
            self.current_delay * 0.95
        )
        self.error_count = 0
        
    def on_rate_limit(self):
        # Plötzliche Verlangsamung bei Sperrung
        self.error_count += 1
        self.current_delay = min(
            self.max_delay,
            self.current_delay * (1.5 + self.error_count * 0.5)
        )
        print(f"Ratenlimit erreicht. Neue Verzögerung: {self.current_delay:.2f}s")

# Anwendung
limiter = AdaptiveRateLimiter(initial_delay=2.0)

for url in urls:
    limiter.wait()
    response = session.get(url)
    
    if response.status_code == 429:
        limiter.on_rate_limit()
        time.sleep(60)  # Pause vor dem Wiederholen
    elif response.status_code == 200:
        limiter.on_success()
    else:
        # Behandlung anderer Fehler
        pass

Proxy-Rotation und IP-Management

Die Verwendung einer einzigen IP-Adresse für Massenanfragen garantiert eine Sperrung. Die Proxy-Rotation verteilt die Last und verringert das Risiko der Erkennung.

Rotationsstrategien

1. Anfragebasierte Rotation: Wechseln der IP nach jeder oder nach N Anfragen. Geeignet für das Scraping von Suchmaschinen, wo die Anonymität jeder Anfrage wichtig ist.

2. Zeitbasierte Rotation: Wechseln der IP alle 5-15 Minuten. Effektiv für die Arbeit mit sozialen Netzwerken, wo die Stabilität der Sitzung wichtig ist.

3. Sticky Sessions: Verwendung einer IP für die gesamte Benutzersitzung (Authentifizierung, Abfolge von Aktionen). Kritisch für Websites mit CSRF-Schutz.

import requests
from itertools import cycle

class ProxyRotator:
    def __init__(self, proxy_list, rotation_type='request', rotation_interval=10):
        """
        rotation_type: 'request' (jede Anfrage) oder 'time' (nach Zeit)
        rotation_interval: Anzahl der Anfragen oder Sekunden
        """
        self.proxies = cycle(proxy_list)
        self.current_proxy = next(self.proxies)
        self.rotation_type = rotation_type
        self.rotation_interval = rotation_interval
        self.request_count = 0
        self.last_rotation = time.time()
        
    def get_proxy(self):
        if self.rotation_type == 'request':
            self.request_count += 1
            if self.request_count >= self.rotation_interval:
                self.current_proxy = next(self.proxies)
                self.request_count = 0
                print(f"Rotiert zu: {self.current_proxy}")
                
        elif self.rotation_type == 'time':
            if time.time() - self.last_rotation >= self.rotation_interval:
                self.current_proxy = next(self.proxies)
                self.last_rotation = time.time()
                print(f"Rotiert zu: {self.current_proxy}")
                
        return {'http': self.current_proxy, 'https': self.current_proxy}

# Beispielverwendung
proxy_list = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    'http://user:pass@proxy3.example.com:8000',
]

rotator = ProxyRotator(proxy_list, rotation_type='request', rotation_interval=5)

for url in urls:
    proxies = rotator.get_proxy()
    response = requests.get(url, proxies=proxies, timeout=10)

Auswahl des Proxy-Typs

Für Massenoperationen in sozialen Netzwerken und auf Plattformen mit ernsthaften Schutzmaßnahmen verwenden Sie Residential Proxies. Diese sehen aus wie normale Heimverbindungen und landen selten auf schwarzen Listen. Rechenzentren sind für weniger geschützte Ressourcen geeignet, wo Geschwindigkeit wichtig ist.

Browser-Fingerprinting und TLS-Fingerabdrücke

Selbst mit IP-Rotation können Sie durch technische Fingerabdrücke des Browsers und der TLS-Verbindung identifiziert werden. Diese Parameter sind einzigartig für jeden Client und schwer zu fälschen.

TLS-Fingerprinting

Bei der Herstellung einer HTTPS-Verbindung sendet der Client ein ClientHello mit einer Reihe unterstützter Cipher und Erweiterungen. Diese Kombination ist einzigartig für jede Bibliothek. Zum Beispiel verwendet Python requests OpenSSL, dessen Fingerabdruck leicht von dem von Chrome unterschieden werden kann.

Lösung: Verwenden Sie Bibliotheken, die TLS-Fingerabdrücke von Browsern imitieren. Für Python sind dies curl_cffi, tls_client oder playwright/puppeteer für eine vollständige Browseremulation.

# Installation: pip install curl-cffi
from curl_cffi import requests

# Imitation von Chrome 110
response = requests.get(
    'https://example.com',
    impersonate="chrome110",
    proxies={'https': 'http://proxy:port'}
)

# Alternative: tls_client
import tls_client

session = tls_client.Session(
    client_identifier="chrome_108",
    random_tls_extension_order=True
)

response = session.get('https://example.com')

HTTP/2-Fingerprinting

Neben TLS analysieren Anti-Bot-Systeme die HTTP/2-Parameter: Reihenfolge der Header, Einstellungen des SETTINGS-Frames, Stream-Prioritäten. Standardbibliotheken halten nicht die genaue Reihenfolge der Header von Chrome oder Firefox ein.

# Richtige Reihenfolge der Header für Chrome
headers = {
    ':method': 'GET',
    ':authority': 'example.com',
    ':scheme': 'https',
    ':path': '/',
    'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'upgrade-insecure-requests': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...',
    'accept': 'text/html,application/xhtml+xml...',
    'sec-fetch-site': 'none',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-user': '?1',
    'sec-fetch-dest': 'document',
    'accept-encoding': 'gzip, deflate, br',
    'accept-language': 'en-US,en;q=0.9',
}

Canvas und WebGL-Fingerprinting

Browser rendern Grafiken unterschiedlich, abhängig von GPU, Treibern und OS. Websites nutzen dies, um einen einzigartigen Fingerabdruck des Geräts zu erstellen. Bei der Verwendung von Headless-Browsern (Selenium, Puppeteer) ist es wichtig, Anzeichen von Automatisierung zu maskieren:

// Puppeteer: Headless-Modus verbergen
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    headless: true,
    args: [
        '--disable-blink-features=AutomationControlled',
        '--no-sandbox',
        '--disable-setuid-sandbox',
        `--proxy-server=${proxyUrl}`
    ]
});

const page = await browser.newPage();

// Überschreiben von navigator.webdriver
await page.evaluateOnNewDocument(() => {
    Object.defineProperty(navigator, 'webdriver', {
        get: () => false,
    });
});

Header, Cookies und Sitzungsmanagement

Eine korrekte Handhabung von HTTP-Headern und Cookies ist entscheidend für die Simulation eines echten Benutzers. Fehler in diesen Parametern sind eine häufige Ursache für Sperren.

Obligatorische Header

Das Mindestset an Headern zur Imitation des Chrome-Browsers:

import requests

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,*/*;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',
    'Cache-Control': 'max-age=0',
}

session = requests.Session()
session.headers.update(headers)

Cookie-Management

Viele Websites setzen Tracking-Cookies beim ersten Besuch und überprüfen deren Vorhandensein bei nachfolgenden Anfragen. Das Fehlen von Cookies oder deren Inkonsistenz ist ein Zeichen für einen Bot.

import requests
import pickle

class SessionManager:
    def __init__(self, session_file='session.pkl'):
        self.session_file = session_file
        self.session = requests.Session()
        self.load_session()
        
    def load_session(self):
        """Laden der gespeicherten Sitzung"""
        try:
            with open(self.session_file, 'rb') as f:
                cookies = pickle.load(f)
                self.session.cookies.update(cookies)
        except FileNotFoundError:
            pass
            
    def save_session(self):
        """Speichern von Cookies zur Wiederverwendung"""
        with open(self.session_file, 'wb') as f:
            pickle.dump(self.session.cookies, f)
            
    def request(self, url, **kwargs):
        response = self.session.get(url, **kwargs)
        self.save_session()
        return response

# Verwendung
manager = SessionManager('instagram_session.pkl')
response = manager.request('https://www.instagram.com/explore/')

Referer und Origin

Die Header Referer und Origin zeigen, woher der Benutzer kommt. Ihr Fehlen oder inkorrekte Werte sind ein rotes Signal.

# Richtige Reihenfolge: Startseite → Kategorie → Produkt
session = requests.Session()

# Schritt 1: Besuch der Startseite
response = session.get('https://example.com/')

# Schritt 2: Wechsel zur Kategorie
response = session.get(
    'https://example.com/category/electronics',
    headers={'Referer': 'https://example.com/'}
)

# Schritt 3: Produktansicht
response = session.get(
    'https://example.com/product/12345',
    headers={'Referer': 'https://example.com/category/electronics'}
)

Simulation menschlichen Verhaltens

Technische Parameter sind nur die halbe Miete. Moderne Anti-Bot-Systeme analysieren Verhaltensmuster: wie der Benutzer mit der Seite interagiert, wie viel Zeit er verbringt, wie sich die Maus bewegt.

Scrollen und Mausbewegung

Bei der Verwendung von Selenium oder Puppeteer fügen Sie zufällige Mausbewegungen und Seiten-Scrolling hinzu:

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
import random
import time

def human_like_mouse_move(driver):
    """Zufällige Mausbewegung auf der Seite"""
    action = ActionChains(driver)
    
    for _ in range(random.randint(3, 7)):
        x = random.randint(0, 1000)
        y = random.randint(0, 800)
        action.move_by_offset(x, y)
        action.pause(random.uniform(0.1, 0.3))
    
    action.perform()

def human_like_scroll(driver):
    """Simulation natürlichen Scrollens"""
    total_height = driver.execute_script("return document.body.scrollHeight")
    current_position = 0
    
    while current_position < total_height:
        # Zufälliger Scrollschritt
        scroll_step = random.randint(100, 400)
        current_position += scroll_step
        
        driver.execute_script(f"window.scrollTo(0, {current_position});")
        
        # Pause mit Variation
        time.sleep(random.uniform(0.5, 1.5))
        
        # Manchmal ein wenig zurückscrollen (wie es Menschen tun)
        if random.random() < 0.2:
            back_scroll = random.randint(50, 150)
            current_position -= back_scroll
            driver.execute_script(f"window.scrollTo(0, {current_position});")
            time.sleep(random.uniform(0.3, 0.8))

# Verwendung
driver = webdriver.Chrome()
driver.get('https://example.com')

human_like_mouse_move(driver)
time.sleep(random.uniform(2, 4))
human_like_scroll(driver)

Zeit auf der Seite

Echte Benutzer verbringen Zeit auf der Seite: sie lesen Inhalte, betrachten Bilder. Ein Bot, der sofort auf Links klickt, wird leicht erkannt.

def realistic_page_view(driver, url, min_time=5, max_time=15):
    """
    Realistischer Seitenaufruf mit Aktivität
    """
    driver.get(url)
    
    # Anfangsverzögerung (Laden und "Lesen")
    time.sleep(random.uniform(2, 4))
    
    # Scrollen
    human_like_scroll(driver)
    
    # Zusätzliche Aktivität
    total_time = random.uniform(min_time, max_time)
    elapsed = 0
    
    while elapsed < total_time:
        action_choice = random.choice(['scroll', 'mouse_move', 'pause'])
        
        if action_choice == 'scroll':
            # Leichtes Scrollen nach oben/unten
            scroll_amount = random.randint(-200, 300)
            driver.execute_script(f"window.scrollBy(0, {scroll_amount});")
            pause = random.uniform(1, 3)
            
        elif action_choice == 'mouse_move':
            human_like_mouse_move(driver)
            pause = random.uniform(0.5, 2)
            
        else:  # pause
            pause = random.uniform(2, 5)
        
        time.sleep(pause)
        elapsed += pause

Navigationsmuster

Vermeiden Sie verdächtige Muster: direkte Übergänge zu tiefen Seiten, Ignorieren der Startseite, sequentielles Durchklicken aller Elemente ohne Pausen.

Umgehung von Cloudflare, DataDome und anderen Schutzmaßnahmen

Spezialisierte Anti-Bot-Systeme erfordern einen umfassenden Ansatz. Sie verwenden JavaScript-Herausforderungen, CAPTCHA, Echtzeitanalyse des Verhaltens.

Cloudflare

Cloudflare verwendet mehrere Schutzebenen: Browser-Integritätsprüfung, JavaScript-Herausforderung, CAPTCHA. Um den grundlegenden Schutz zu umgehen, reicht ein korrekter TLS-Fingerabdruck und die Ausführung von JavaScript:

# Option 1: cloudscraper (automatische Lösung von JS-Herausforderungen)
import cloudscraper

scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

response = scraper.get('https://protected-site.com')

# Option 2: undetected-chromedriver (für komplexe Fälle)
import undetected_chromedriver as uc

options = uc.ChromeOptions()
options.add_argument('--proxy-server=http://proxy:port')

driver = uc.Chrome(options=options)
driver.get('https://protected-site.com')

# Warten auf die Herausforderung
time.sleep(5)

# Cookies für requests abrufen
cookies = driver.get_cookies()
session = requests.Session()
for cookie in cookies:
    session.cookies.set(cookie['name'], cookie['value'])

DataDome

DataDome analysiert das Benutzerverhalten in Echtzeit: Mausbewegungen, Tippverhalten, Timings. Umgehung erfordert einen vollständigen Browser mit Simulation von Aktivitäten:

from playwright.sync_api import sync_playwright
import random

def bypass_datadome(url, proxy=None):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # DataDome erkennt headless
            proxy={'server': proxy} if proxy else None
        )
        
        context = browser.new_context(
            viewport={'width': 1920, 'height': 1080},
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
        )
        
        page = context.new_page()
        
        # Skripte zur Maskierung der Automatisierung injizieren
        page.add_init_script("""
            Object.defineProperty(navigator, 'webdriver', {get: () => false});
            window.chrome = {runtime: {}};
        """)
        
        page.goto(url)
        
        # Simulation menschlichen Verhaltens
        time.sleep(random.uniform(2, 4))
        
        # Zufällige Mausbewegungen
        for _ in range(random.randint(5, 10)):
            page.mouse.move(
                random.randint(100, 1800),
                random.randint(100, 1000)
            )
            time.sleep(random.uniform(0.1, 0.3))
        
        # Scrollen
        page.evaluate(f"window.scrollTo(0, {random.randint(300, 800)})")
        time.sleep(random.uniform(1, 2))
        
        content = page.content()
        browser.close()
        
        return content

CAPTCHA

Für die automatische Lösung von CAPTCHA verwenden Sie Erkennungsdienste (2captcha, Anti-Captcha) oder Vermeidungsstrategien:

• Reduzieren Sie die Anfragerate auf ein Niveau, das kein CAPTCHA auslöst
• Verwenden Sie saubere Residential IPs mit guter Reputation
• Arbeiten Sie über autorisierte Konten (dort ist die CAPTCHA-Schwelle höher)
• Verteilen Sie die Last über die Zeit (vermeiden Sie Spitzenzeiten)

Überwachung und Umgang mit Sperren

Selbst mit den besten Praktiken sind Sperren unvermeidlich. Es ist wichtig, sie schnell zu erkennen und korrekt zu behandeln.

Sperrindikatoren

Wiederholungsstrategie

import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_session_with_retries():
    """
    Sitzung mit automatischen Wiederholungen und Fehlerbehandlung
    """
    session = requests.Session()
    
    retry_strategy = Retry(
        total=5,
        backoff_factor=2,  # 2, 4, 8, 16, 32 Sekunden
        status_forcelist=[429, 500, 502, 503, 504],
        method_whitelist=["GET", "POST"]
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

def safe_request(url, session, max_attempts=3):
    """
    Anfrage mit Behandlung von Sperren
    """
    for attempt in range(max_attempts):
        try:
            response = session.get(url, timeout=15)
            
            # Überprüfung auf Sperrung
            if response.status_code == 403:
                print(f"IP blockiert. Proxy wechselt...")
                # Logik zum Wechseln des Proxys
                continue
                
            elif response.status_code == 429:
                wait_time = int(response.headers.get('Retry-After', 60))
                print(f"Ratenbegrenzung. Warte {wait_time}s...")
                time.sleep(wait_time)
                continue
                
            elif 'captcha' in response.text.lower():
                print("CAPTCHA erkannt")
                # Logik zur Lösung von CAPTCHA oder zum Überspringen
                return None
                
            return response
            
        except requests.exceptions.Timeout:
            print(f"Timeout bei Versuch {attempt + 1}")
            time.sleep(5 * (attempt + 1))
            
        except requests.exceptions.ProxyError:
            print("Proxy-Fehler. Wechseln...")
            # Wechseln des Proxys
            continue
            
    return None

Protokollierung und Analyse

Verfolgen Sie Metriken zur Optimierung der Strategie:

import logging
from collections import defaultdict
from datetime import datetime

class ScraperMetrics:
    def __init__(self):
        self.stats = {
            'total_requests': 0,
            'successful': 0,
            'rate_limited': 0,
            'blocked': 0,
            'captcha': 0,
            'errors': 0,
            'proxy_failures': defaultdict(int)
        }
        
    def log_request(self, status, proxy=None):
        self.stats['total_requests'] += 1
        
        if status == 200:
            self.stats['successful'] += 1
        elif status == 429:
            self.stats['rate_limited'] += 1
        elif status == 403:
            self.stats['blocked'] += 1
            if proxy:
                self.stats['proxy_failures'][proxy] += 1
                
    def get_success_rate(self):
        if self.stats['total_requests'] == 0:
            return 0
        return (self.stats['successful'] / self.stats['total_requests']) * 100
        
    def print_report(self):
        print(f"\n=== Scraping-Bericht ===")
        print(f"Gesamtanfragen: {self.stats['total_requests']}")
        print(f"Erfolgsquote: {self.get_success_rate():.2f}%")
        print(f"Ratenbegrenzung: {self.stats['rate_limited']}")
        print(f"Blockiert: {self.stats['blocked']}")
        print(f"CAPTCHA: {self.stats['captcha']}")
        
        if self.stats['proxy_failures']:
            print(f"\nProblematische Proxys:")
            for proxy, count in sorted(
                self.stats['proxy_failures'].items(), 
                key=lambda x: x[1], 
                reverse=True
            )[:5]:
                print(f"  {proxy}: {count} Fehler")

# Verwendung
metrics = ScraperMetrics()

for url in urls:
    response = safe_request(url, session)
    if response:
        metrics.log_request(response.status_code, current_proxy)
    
metrics.print_report()

Fazit

Schutzmaßnahmen gegen Sperren sind entscheidend für erfolgreiches Scraping und die Automatisierung von Prozessen. Durch das Verständnis der Mechanismen zur Erkennung und die Implementierung geeigneter Techniken können Sie die Wahrscheinlichkeit von Sperren erheblich reduzieren.