API-Ratenbegrenzung beim Scraping über Proxys umgehen: Rotationskonfiguration und IP-Auswahl

Sie haben einen Parser eingerichtet, Proxys angeschlossen, aber die API gibt weiterhin Fehler 429 "Zu viele Anfragen" zurück oder blockiert den Zugriff? Das Problem liegt nicht an den Proxys selbst, sondern an einer falschen Strategie ihrer Nutzung. Rate Limiting ist ein Schutzmechanismus der API, der die Anzahl der Anfragen von einer IP-Adresse über einen bestimmten Zeitraum begrenzt. In diesem Artikel werden wir untersuchen, warum Blockierungen bei der Arbeit über Proxys auftreten und wie man das System richtig konfiguriert, um die Grenzen zu umgehen.

Was ist API Rate Limiting und wie funktioniert es?

Rate Limiting (Anfragefrequenzbegrenzung) ist ein Schutzmechanismus der API gegen Überlastungen und Missbrauch. Der Dienst legt ein Limit für die Anzahl der Anfragen fest, die von einer Quelle über einen bestimmten Zeitraum ausgeführt werden können. Beispielsweise verwenden beliebte APIs solche Einschränkungen:

• Twitter API: 300 Anfragen alle 15 Minuten für den Standardzugang
• Instagram Graph API: 200 Anfragen pro Stunde pro Anwendung
• Google Maps API: abhängig vom Tarif, normalerweise 100-1000 Anfragen pro Tag
• Wildberries API: inoffizielle Limits von etwa 60 Anfragen pro Minute von einer IP
• Avito API: 10 Anfragen pro Sekunde für das Scraping von Anzeigen

Es gibt mehrere Methoden zur Bestimmung der Quelle von Anfragen, auf die Rate Limiting angewendet wird:

Wenn das Limit überschritten wird, gibt die API den HTTP-Status 429 "Zu viele Anfragen" und den Header Retry-After zurück, der die Zeit bis zum Zurücksetzen des Limits angibt. Einige Dienste verwenden ein "gleitendes Fenster" (rolling window), bei dem das Limit schrittweise aktualisiert wird, während andere ein festes Fenster verwenden, das zu einem bestimmten Zeitpunkt zurückgesetzt wird.

Warum Proxys nicht automatisch vor Rate Limiting schützen

Viele Entwickler glauben fälschlicherweise, dass es ausreicht, Proxys anzuschließen, um eine unbegrenzte Anzahl von Anfragen zu senden. In der Praxis treten folgende Probleme auf:

Verwendung eines Proxys für alle Anfragen

Wenn Ihr Skript dieselbe IP-Adresse des Proxys für alle Anfragen verwendet, sieht die API dies als normalen Benutzer und wendet die Standardlimits an. Angenommen, Sie haben einen Preisparser von Wildberries über einen einzigen Residential Proxy eingerichtet. Der Parser macht 100 Anfragen pro Minute, aber das Limit liegt bei 60 Anfragen. Ergebnis: Blockierung der IP für 10-30 Minuten.

Langsame IP-Rotation

Einige verwenden einen Pool von 5-10 Proxys und wechseln nacheinander zwischen ihnen. Das Problem ist, dass jede IP das Limit schneller erreicht, als eine vollständige Rotation erfolgt. Angenommen, Sie haben 10 Proxys und ein Limit von 100 Anfragen pro Stunde und IP. Wenn Sie 1000 Anfragen pro Stunde machen, erhält jeder Proxy 100 Anfragen - genau an der Grenze des Limits. Jede Ungleichmäßigkeit in der Verteilung führt zu Blockierungen.

Ignorieren anderer Identifikationsfaktoren

Selbst bei idealer IP-Rotation können Sie blockiert werden, wenn:

• Alle Anfragen kommen mit demselben User-Agent (z.B. python-requests/2.28.0)
• Ein API-Schlüssel für alle Anfragen verwendet wird
• Anfragen mit perfekter Regelmäßigkeit (alle 0,5 Sekunden) eintreffen - das sieht aus wie ein Bot
• Die IP-Adressen der Proxys sich im selben Subnetz befinden (z.B. alle im Bereich 192.168.1.x)

Reputation der IP-Adressen

Datacenter-Proxys werden häufig auf schwarze Listen gesetzt, da ihre IP-Adressen von Hunderten anderer Benutzer zum Scraping verwendet werden. Die API kann strengere Limits für solche Adressen anwenden oder sie sofort blockieren. Beispielsweise sperren Instagram und Facebook aggressiv Datacenter, selbst wenn Sie die offiziellen Limits nicht überschreiten.

IP-Rotationsstrategien zur Umgehung von Limits

Die richtige Rotation von Proxys ist der Schlüssel zur Umgehung von Rate Limiting. Lassen Sie uns effektive Strategien je nach Aufgabe betrachten.

Rotation nach jeder Anfrage

Die aggressivste Strategie: jede Anfrage erfolgt über eine neue IP. Geeignet für Aufgaben mit sehr strengen Limits (1-5 Anfragen pro IP) oder wenn die Last maximal verteilt werden muss. Dafür werden Residential Proxys mit automatischer Rotation verwendet - sie bieten einen Pool von Millionen IPs, und jede Anfrage erhält automatisch eine neue Adresse.

Beispiel: Scraping von Instagram über eine inoffizielle API, bei der das Limit 5 Anfragen pro Minute von einer IP beträgt. Mit der Rotation nach jeder Anfrage können Sie 300 Anfragen pro Minute über 300 verschiedene IPs durchführen.

Zeitbasierte Rotation (Sticky Sessions)

Die IP-Adresse wird für einen bestimmten Zeitraum (5-30 Minuten) verwendet und dann auf eine neue geändert. Diese Strategie eignet sich für APIs, die eine Sitzung erfordern, oder wenn mehrere zusammenhängende Anfragen von einem "Benutzer" gestellt werden müssen.

Berechnung der optimalen Rotationszeit: Wenn das API-Limit 100 Anfragen pro Stunde beträgt und Sie planen, 50 Anfragen über eine IP zu machen, verwenden Sie eine Sticky Session von 30 Minuten. In dieser Zeit machen Sie 25 Anfragen (bei gleichmäßiger Last), was die Hälfte des Limits beträgt.

Rotation nach Pool mit Limitverfolgung

Eine fortgeschrittene Strategie: Ihr Skript verfolgt die Anzahl der Anfragen von jeder IP und wechselt automatisch zu einer neuen, wenn das Limit erreicht wird. Angenommen, Sie haben einen Pool von 20 Proxys, das API-Limit beträgt 100 Anfragen pro Stunde. Das Skript verfolgt den Zähler für jede IP und wechselt zur nächsten, wenn 90 Anfragen erreicht sind.

Diese Strategie erfordert Programmierlogik, bietet jedoch maximale Effizienz: Sie nutzen jeden Proxy voll aus, ohne die Limits zu überschreiten.

Geografische Rotation

Einige APIs wenden unterschiedliche Limits je nach Region an. Beispielsweise kann ein Dienst Anfragen aus den USA strenger einschränken als aus Europa. In solchen Fällen verwenden Sie Proxys aus verschiedenen Ländern und verteilen die Last zwischen ihnen.

Einstellung von Verzögerungen zwischen Anfragen

Selbst bei idealer IP-Rotation ist es wichtig, die Verzögerungen zwischen den Anfragen richtig einzustellen. Zu schnelle Anfragen sehen wie ein Angriff aus, selbst wenn sie von verschiedenen IPs kommen.

Berechnung der minimalen Verzögerung

Formel: Verzögerung = (Zeitfenster in Sekunden / Anfrage-Limit) × Sicherheitsfaktor

Beispiel: Die API erlaubt 100 Anfragen pro Stunde (3600 Sekunden). Minimale Verzögerung = 3600 / 100 = 36 Sekunden. Sicherheitsfaktor 1.2 hinzufügen: 36 × 1.2 = 43 Sekunden zwischen Anfragen von einer IP.

Wenn Sie 10 Proxys mit Rotation verwenden, können Sie alle 4,3 Sekunden Anfragen stellen (43 / 10), ohne das Limit an einer IP zu überschreiten.

Zufällige Verzögerungen (Jitter)

Verwenden Sie anstelle einer festen Verzögerung von 5 Sekunden zufällige Intervalle, z.B. von 3 bis 7 Sekunden. Dies macht Ihren Verkehr ähnlicher zu dem eines echten Benutzers. Viele Bot-Schutzsysteme analysieren Muster: Wenn Anfragen genau alle 5,0 Sekunden eintreffen, ist das verdächtig.

Exponentielle Verzögerung bei Fehlern

Wenn Sie einen Fehler 429 erhalten, senden Sie nicht sofort weitere Anfragen. Verwenden Sie eine exponentielle Verzögerung: erster Versuch nach 1 Sekunde, zweiter nach 2, dritter nach 4, vierter nach 8 und so weiter. Dies ist eine gängige Praxis, die APIs von ihren Clients erwarten.

Welchen Proxytyp für die Arbeit mit APIs wählen?

Die Wahl des Proxytyps hat einen entscheidenden Einfluss auf den Erfolg der Umgehung von Rate Limiting. Lassen Sie uns die Vor- und Nachteile jeder Option für die Arbeit mit APIs untersuchen.

Residential Proxys

Residential Proxys verwenden IP-Adressen echter Benutzer, die von Internetanbietern zugewiesen werden. Für APIs sieht dies aus wie normales Heim-Internet.

Wann verwenden: Scraping von Instagram, Facebook, TikTok, Arbeiten mit API-Marktplätzen (Wildberries, Ozon), alle Aufgaben, bei denen die Reputation der IP entscheidend ist.

Mobile Proxys

Mobile Proxys verwenden IP-Adressen von Mobilfunkanbietern (4G/5G). Eine IP wird häufig von Tausenden echten Benutzern gleichzeitig verwendet, daher blockieren APIs sie extrem selten.

Wann verwenden: Arbeiten mit mobilen APIs, Scraping von Instagram/TikTok in großen Mengen, wenn maximaler Schutz vor Sperrungen erforderlich ist.

Datacenter-Proxys

Datacenter-Proxys sind IP-Adressen von Servern, die in Rechenzentren untergebracht sind. Sie sind nicht mit echten Benutzern verbunden.

Wann verwenden: Scraping von öffentlichen APIs ohne strengen Schutz (Wetter, Wechselkurse, Nachrichten), Arbeiten mit eigenen APIs, Testen und Entwickeln.

Praktische Umsetzung: Codebeispiele in Python

Lassen Sie uns konkrete Beispiele für die Umsetzung der Umgehung von Rate Limiting mit Proxys betrachten. Alle Beispiele sind in Python mit der Bibliothek requests.

Einfache Rotation aus einem Proxy-Pool

Basisimplementierung mit zyklischer Rotation der IP aus einer Liste:

import requests
import time
from itertools import cycle

# Liste der Proxys (Format: protocol://user:pass@host:port)
PROXY_LIST = [
    'http://user1:pass1@proxy1.example.com:8080',
    'http://user2:pass2@proxy2.example.com:8080',
    'http://user3:pass3@proxy3.example.com:8080',
]

# Erstellen eines zyklischen Iterators
proxy_pool = cycle(PROXY_LIST)

def make_request(url):
    proxy = next(proxy_pool)  # Nächsten Proxy aus dem Pool nehmen
    proxies = {
        'http': proxy,
        'https': proxy
    }
    
    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        return response
    except requests.exceptions.RequestException as e:
        print(f"Fehler mit Proxy {proxy}: {e}")
        return None

# Beispielverwendung
for i in range(10):
    response = make_request('https://api.example.com/data')
    if response and response.status_code == 200:
        print(f"Anfrage {i+1}: Erfolg")
    time.sleep(2)  # Verzögerung zwischen Anfragen

Rotation mit Limitverfolgung

Eine fortgeschrittenere Version, die die Anfragen für jeden Proxy zählt und beim Annähern an das Limit wechselt:

import requests
import time
from collections import defaultdict

class ProxyRotator:
    def __init__(self, proxy_list, max_requests_per_ip=90, time_window=3600):
        self.proxy_list = proxy_list
        self.max_requests = max_requests_per_ip  # Anfrage-Limit pro IP
        self.time_window = time_window  # Zeitfenster in Sekunden
        self.request_counts = defaultdict(list)  # Anfragehistorie für jede IP
        self.current_index = 0
    
    def get_proxy(self):
        """Gibt den Proxy mit der geringsten Anzahl an Anfragen zurück"""
        current_time = time.time()
        
        # Alte Einträge außerhalb des Zeitfensters löschen
        for proxy in self.request_counts:
            self.request_counts[proxy] = [
                t for t in self.request_counts[proxy]
                if current_time - t < self.time_window
            ]
        
        # Proxy mit der geringsten Anzahl an Anfragen suchen
        available_proxies = []
        for proxy in self.proxy_list:
            count = len(self.request_counts[proxy])
            if count < self.max_requests:
                available_proxies.append((proxy, count))
        
        if not available_proxies:
            # Wenn alle Proxys das Limit erreicht haben, warten
            oldest_request = min(
                min(times) for times in self.request_counts.values() if times
            )
            wait_time = self.time_window - (current_time - oldest_request) + 1
            print(f"Alle Proxys haben das Limit erreicht. Wartezeit {wait_time:.0f} Sek...")
            time.sleep(wait_time)
            return self.get_proxy()
        
        # Proxy mit der geringsten Anzahl an Anfragen auswählen
        proxy = min(available_proxies, key=lambda x: x[1])[0]
        self.request_counts[proxy].append(current_time)
        return proxy
    
    def make_request(self, url, **kwargs):
        proxy = self.get_proxy()
        proxies = {'http': proxy, 'https': proxy}
        
        try:
            response = requests.get(url, proxies=proxies, timeout=10, **kwargs)
            return response
        except requests.exceptions.RequestException as e:
            print(f"Fehler mit Proxy {proxy}: {e}")
            return None

# Beispielverwendung
PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
]

rotator = ProxyRotator(PROXY_LIST, max_requests_per_ip=100, time_window=3600)

for i in range(500):  # 500 Anfragen stellen
    response = rotator.make_request('https://api.example.com/data')
    if response and response.status_code == 200:
        print(f"Anfrage {i+1}: Erfolg")
    time.sleep(1)  # Minimale Verzögerung

Fehler 429 mit exponentieller Verzögerung behandeln

Richtige Behandlung der Antwort "Zu viele Anfragen" unter Berücksichtigung des Headers Retry-After:

import requests
import time

def make_request_with_retry(url, proxies, max_retries=5):
    """Macht eine Anfrage mit automatischen Wiederholungen bei Fehler 429"""
    
    for attempt in range(max_retries):
        try:
            response = requests.get(url, proxies=proxies, timeout=10)
            
            if response.status_code == 200:
                return response
            
            elif response.status_code == 429:
                # Überprüfen des Headers Retry-After
                retry_after = response.headers.get('Retry-After')
                
                if retry_after:
                    wait_time = int(retry_after)
                    print(f"Rate limit. Wartezeit {wait_time} Sek (aus Retry-After)")
                else:
                    # Exponentielle Verzögerung: 2^attempt Sekunden
                    wait_time = 2 ** attempt
                    print(f"Rate limit. Versuch {attempt+1}, Wartezeit {wait_time} Sek")
                
                time.sleep(wait_time)
                continue
            
            else:
                print(f"HTTP-Fehler {response.status_code}")
                return None
        
        except requests.exceptions.RequestException as e:
            print(f"Verbindungsfehler: {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
                continue
            return None
    
    print(f"Maximale Anzahl an Versuchen überschritten ({max_retries})")
    return None

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

response = make_request_with_retry('https://api.example.com/data', proxies)
if response:
    print("Daten erhalten:", response.json())

Verwendung von Residential Proxys mit automatischer Rotation

Viele Anbieter von Residential Proxys bieten einen Endpunkt an, der bei jeder Anfrage automatisch die IP wechselt. Beispielkonfiguration:

import requests
import random
import time

# Residential Proxys mit automatischer Rotation
# Format: protocol://username:password@gateway:port
ROTATING_PROXY = 'http://customer-USER:PASS@proxy.provider.com:12321'

def make_request_rotating(url):
    """Anfrage über rotierenden Proxy (neue IP jedes Mal)"""
    proxies = {
        'http': ROTATING_PROXY,
        'https': ROTATING_PROXY
    }
    
    # Fügen Sie einen zufälligen User-Agent für mehr Anonymität hinzu
    user_agents = [
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36',
    ]
    
    headers = {
        'User-Agent': random.choice(user_agents)
    }
    
    try:
        response = requests.get(url, proxies=proxies, headers=headers, timeout=15)
        return response
    except requests.exceptions.RequestException as e:
        print(f"Fehler: {e}")
        return None

# 100 Anfragen über verschiedene IPs stellen
for i in range(100):
    response = make_request_rotating('https://api.example.com/data')
    if response and response.status_code == 200:
        print(f"Anfrage {i+1}: Erfolg, IP geändert")
    
    # Zufällige Verzögerung von 1-3 Sekunden
    time.sleep(random.uniform(1, 3))

Überwachung von Limits und Fehlerbehandlung

Effektive Arbeit mit APIs erfordert ständige Überwachung der Limits und richtige Fehlerbehandlung. Hier sind die wichtigsten Praktiken:

Analyse der Antwort-Header

Viele APIs geben Informationen über Limits in den Antwort-Headern zurück. Standardheader:

• X-RateLimit-Limit — maximale Anzahl an Anfragen im Fenster
• X-RateLimit-Remaining — wie viele Anfragen noch übrig sind
• X-RateLimit-Reset — Zeit des Zurücksetzens des Limits (Unix-Zeitstempel)
• Retry-After — nach wie vielen Sekunden die Anfrage wiederholt werden kann

Beispiel zum Lesen dieser Header:

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

# Überprüfen der Limit-Header
limit = response.headers.get('X-RateLimit-Limit')
remaining = response.headers.get('X-RateLimit-Remaining')
reset_time = response.headers.get('X-RateLimit-Reset')

if remaining:
    remaining = int(remaining)
    if remaining < 10:
        print(f"Achtung! Nur noch {remaining} Anfragen übrig")
        
if reset_time:
    import datetime
    reset_dt = datetime.datetime.fromtimestamp(int(reset_time))
    print(f"Das Limit wird um {reset_dt} zurückgesetzt")

Protokollierung und Statistik

Führen Sie detaillierte Statistiken über Anfragen für jeden Proxy. Dies hilft, problematische IPs zu identifizieren und die Rotation zu optimieren:

import json
from datetime import datetime

class RequestLogger:
    def __init__(self):
        self.stats = {}
    
    def log_request(self, proxy, status_code, response_time):
        if proxy not in self.stats:
            self.stats[proxy] = {
                'total': 0,
                'success': 0,
                'rate_limited': 0,
                'errors': 0,
                'avg_response_time': 0
            }
        
        self.stats[proxy]['total'] += 1
        
        if status_code == 200:
            self.stats[proxy]['success'] += 1
        elif status_code == 429:
            self.stats[proxy]['rate_limited'] += 1
        else:
            self.stats[proxy]['errors'] += 1
        
        # Aktualisieren der durchschnittlichen Antwortzeit
        current_avg = self.stats[proxy]['avg_response_time']
        total = self.stats[proxy]['total']
        self.stats[proxy]['avg_response_time'] = (
            (current_avg * (total - 1) + response_time) / total
        )
    
    def print_stats(self):
        print("\n=== Proxy-Statistiken ===")
        for proxy, data in self.stats.items():
            success_rate = (data['success'] / data['total'] * 100) if data['total'] > 0 else 0
            print(f"\nProxy: {proxy}")
            print(f"  Gesamtanfragen: {data['total']}")
            print(f"  Erfolgreiche: {data['success']} ({success_rate:.1f}%)")
            print(f"  Rate limited: {data['rate_limited']}")
            print(f"  Fehler: {data['errors']}")
            print(f"  Durchschnittliche Antwortzeit: {data['avg_response_time']:.2f}s")

# Verwendung
logger = RequestLogger()

start_time = time.time()
response = requests.get(url, proxies=proxies)
response_time = time.time() - start_time

logger.log_request(proxy, response.status_code, response_time)
logger.print_stats()

Automatisches Umschalten der Strategie

Wenn Sie ständig Fehler 429 erhalten, verlangsamen Sie automatisch die Anfragen oder erhöhen Sie den Proxy-Pool:

class AdaptiveRateLimiter:
    def __init__(self, initial_delay=1.0):
        self.delay = initial_delay
        self.consecutive_429 = 0
    
    def on_success(self):
        """Erfolgreiche Anfrage - kann etwas beschleunigt werden"""
        self.consecutive_429 = 0
        self.delay = max(0.5, self.delay * 0.95)  # Verzögerung um 5% reduzieren
    
    def on_rate_limit(self):
        """Fehler 429 erhalten - muss verlangsamt werden"""
        self.consecutive_429 += 1
        self.delay *= 1.5  # Verzögerung um das 1,5-fache erhöhen
        
        if self.consecutive_429 > 5:
            print("WARNUNG: Zu viele Fehler 429. Überprüfen Sie die Einstellungen!")
    
    def wait(self):
        """Warten vor der nächsten Anfrage"""
        time.sleep(self.delay)
        return self.delay

# Verwendung
limiter = AdaptiveRateLimiter(initial_delay=2.0)

for i in range(1000):
    response = make_request(url)
    
    if response.status_code == 200:
        limiter.on_success()
    elif response.status_code == 429:
        limiter.on_rate_limit()
    
    delay = limiter.wait()
    print(f"Anfrage {i+1}, Verzögerung: {delay:.2f}s")

Umgang mit Captchas und anderen Blockierungen

Einige APIs zeigen bei Überschreitung der Limits ein Captcha anstelle einer direkten Blockierung an. Anzeichen:

• Statuscode 403 mit einem Antwortkörper, der "captcha" oder "recaptcha" enthält
• Weiterleitung zu einer Seite mit Captcha (Status 302)
• Spezielle Header wie X-Captcha-Required: true

In solchen Fällen sollten Sie:

1. Die Verwendung dieser IP sofort einstellen
2. Zu einem anderen Proxy aus dem Pool wechseln
3. Die Verzögerungen zwischen den Anfragen erhöhen
4. Mehr Vielfalt in User-Agent und anderen Headern hinzufügen

Fazit

Die Umgehung von API Rate Limiting bei der Verwendung von Proxys ist nicht nur eine technische Einstellung, sondern eine umfassende Strategie, die die richtige Wahl des Proxytyps, die Einstellung der IP-Rotation, das Management von Verzögerungen und die Überwachung von Limits umfasst. Wichtige Erkenntnisse aus dem Artikel:

• Proxys lösen das Problem des Rate Limiting nicht von selbst - eine richtige Rotationsstrategie ist erforderlich
• Für soziale Netzwerke und strenge APIs verwenden Sie Residential oder mobile Proxys, für öffentliche APIs sind Datacenter geeignet
• Berechnen Sie die Größe des Proxy-Pools basierend auf den API-Limits und der gewünschten Scraping-Geschwindigkeit
• Überwachen Sie immer die Limits und passen Sie Ihre Strategie entsprechend an