429 Rate Limited: Zu viele Anfragen beheben

MCP-429-Rate-Limit-Fehler mit Retry-Strategien, Batching und exponentiellem Backoff beheben. Limit-Stufen und Best Practices, um Limits zu vermeiden.

Was sind Rate Limits?

Rate Limits begrenzen Missbrauch und sorgen für faire API-Nutzung. Bei Überschreitung erhalten Sie 429 und müssen vor weiteren Anfragen warten.

Was löst Rate Limits aus?

Zu viele Anfragen in kurzer Zeit
Überschreitung der Anfragen pro Minute oder Stunde
Gleichzeitige Anfragen über dem Limit
Wiederholte aufwändige Abfragen (große Ergebnismengen)

Rate-Limit-Stufen

Kostenloser Tarif

Anfragen pro Minute: 60
Anfragen pro Stunde: 1.000
Gleichzeitige Anfragen: 5
Geeignet für: Privatnutzung, Tests, kleine Workflows

Standard-Tarif

Anfragen pro Minute: 300
Anfragen pro Stunde: 10.000
Gleichzeitige Anfragen: 20
Geeignet für: Teams, regelmäßige Automation, mittlere Nutzung

Enterprise-Tarif

Anfragen pro Minute: 1.000+
Anfragen pro Stunde: Individuelle Limits
Gleichzeitige Anfragen: 100+
Geeignet für: Große Teams, starke Automation, Integrationen

Häufige Ursachen

1. Enge Schleifen ohne Verzögerung

MCP-Tools in einer Schleife ohne Pause zwischen den Anfragen aufrufen:

Problem-Code

// ❌ SCHLECHT: Keine Verzögerung
for task_id in task_ids:
    update_task(task_id, status="done")
    // Trifft nach 60 Anfragen sofort das Limit

Lösung: Verzögerungen einbauen

// ✅ GUT: Verzögerung zwischen Anfragen
for task_id in task_ids:
    update_task(task_id, status="done")
    sleep(100)  // 100 ms = max. 10 Anfragen/Sek.

2. Parallele Anfragen über dem Limit

Zu viele gleichzeitige Anfragen:

Problem

50 parallele Anfragen starten, obwohl das Limit bei 5 liegt.

Lösung: Parallelität begrenzen

In Batches verarbeiten (z. B. 5 bei Free, 20 bei Standard)
Queue mit maximaler Worker-Anzahl nutzen
Semaphore oder Rate-Limiter im Code verwenden

3. Keine Retry-Logik

Bei Rate Limit verschlimmert sofortiges erneutes Senden das Problem:

Problem

Sofortiger Retry nach 429 erzeugt weitere Fehler.

Lösung: Exponentielles Backoff

Zwischen Retries progressiv länger warten: 1 s, 2 s, 4 s, 8 s, 16 s …

Lösungen und Best Practices

1. Exponentielles Backoff nutzen

Retry-Strategie

def call_with_retry(func, max_retries=5):
    retry_count = 0
    base_delay = 1  // Start: 1 Sekunde
    
    while retry_count < max_retries:
        try:
            return func()
        except RateLimitError as e:
            retry_count += 1
            delay = base_delay * (2 ** retry_count)  // Exponential
            print(f"Rate limit. Warte {delay}s...")
            sleep(delay)
    
    raise Exception("Max. Retries überschritten")

2. Stapelverarbeitung (Batching)

Batching-Muster

Mehrere Änderungen in weniger API-Aufrufen bündeln:

Alle gewünschten Änderungen sammeln
In Batches von 10–20 Einträgen gruppieren
Jeden Batch verarbeiten, mit Pause zwischen Batches
Exponentielles Backoff für Retries nutzen

Details im Batching-Guide.

3. Retry-After-Header nutzen

Intelligenter Retry

Die 429-Antwort enthält einen Retry-After-Header mit der Wartezeit:

response = make_request()
if response.status == 429:
    retry_after = response.headers.get('Retry-After', 60)
    print(f"Rate limit. Warte {retry_after}s...")
    sleep(retry_after)
    // Anfrage erneut senden

4. Abfragen optimieren

Anfragen reduzieren

Filter nutzen: Nur nötige Aufgaben abrufen
Paginierung: Kleine Seiten statt großer Ergebnismengen
Caching: Leseergebnisse kurz cachen, wo sinnvoll
Aggregierte Abfragen: Einmal laden, lokal verarbeiten

Beispiel: Rate-Limit-sichere Stapelaktualisierung

Beispiel-Implementierung

import time

def bulk_update_tasks(task_ids, status):
    BATCH_SIZE = 10
    DELAY_BETWEEN_BATCHES = 1  // 1 Sekunde
    MAX_RETRIES = 5
    
    for i in range(0, len(task_ids), BATCH_SIZE):
        batch = task_ids[i:i+BATCH_SIZE]
        retry_count = 0
        
        while retry_count < MAX_RETRIES:
            try:
                for task_id in batch:
                    update_task(task_id, status=status)
                    time.sleep(0.1)  // Kurze Pause zwischen Einträgen
                
                break  // Erfolg, Retry-Schleife verlassen
                
            except RateLimitError as e:
                retry_count += 1
                delay = DELAY_BETWEEN_BATCHES * (2 ** retry_count)
                print(f"Rate limit. Retry {retry_count}/{MAX_RETRIES} in {delay}s")
                time.sleep(delay)
        
        time.sleep(DELAY_BETWEEN_BATCHES)