> ## Documentation Index > Fetch the complete documentation index at: https://docs.localmind.ai/llms.txt > Use this file to discover all available pages before exploring further. # Batching > Batch-Verarbeitung von Items in Automate-Workflows Batch-Verarbeitung fasst mehrere Items zu Gruppen zusammen und verarbeitet sie gemeinsam, statt jeden Datensatz einzeln zu behandeln. Statt drei einzelner API-Calls für drei Items genügt ein Batch-Request — das reduziert API-Calls, hilft Rate Limits einzuhalten und senkt Kosten. Besonders lohnt sich Batching bei großen Datenmengen und bei APIs mit Rate Limits. ## Loop Over Items Node Der Loop Over Items Node (in älteren n8n-Versionen „Split In Batches" genannt) teilt Items in kleinere Gruppen auf. Ein typischer Batch-Workflow: ``` Trigger → Loop Over Items → Process Batch → Merge Results ``` Mit `batchSize: 10` werden aus 30 Input-Items drei Batches zu je 10 Items: ```json Loop Over Items Konfiguration theme={null} { "batchSize": 10, "options": {} } ``` ### Batch-Größe bestimmen Die optimale Batch-Größe hängt von den API-Rate-Limits (z.B. 100 Requests/Minute), der maximalen Batch-Größe der API (z.B. 50 Items), der Verarbeitungszeit pro Batch und den Memory-Limits ab. | Batch-Größe | Geeignet für | | -------------- | -------------------------------------------- | | Klein (5-10) | Schnelle APIs, niedrige Rate Limits | | Mittel (10-50) | Standard für die meisten APIs | | Groß (50-100) | APIs mit hohen Limits, wenn Memory ausreicht | Beginnen Sie mit Batch-Größe 10-20 und passen Sie basierend auf Performance und Rate Limits an. ## Batch-API-Calls ### Batch POST Request Senden Sie mehrere Items in einem Request. `$input.all()` liefert alle Items des aktuellen Node-Inputs; Items eines bestimmten vorherigen Nodes erreichen Sie mit `$('Node Name').all()`. ```json HTTP Request Konfiguration theme={null} { "method": "POST", "url": "https://api.example.com/batch", "body": { "items": "={{ $input.all().map(item => item.json) }}" } } ``` ```json Request Body theme={null} { "items": [ { "id": 1, "name": "Item 1" }, { "id": 2, "name": "Item 2" }, { "id": 3, "name": "Item 3" } ] } ``` ### Batch GET Request Mehrere IDs in einem Request — die URL wird damit z.B. zu `https://api.example.com/items?ids=1,2,3,4,5`: ```json Batch GET theme={null} { "method": "GET", "url": "https://api.example.com/items", "qs": { "ids": "={{ $input.all().map(item => item.json.id).join(',') }}" } } ``` ### Code-Node für Batch-Verarbeitung Für komplexe Batch-Logik nutzen Sie den Code-Node: ```javascript Batch verarbeiten theme={null} // Alle Items aus Batch abrufen const items = $input.all(); // Batch-Request vorbereiten const batchData = { items: items.map(item => ({ id: item.json.id, name: item.json.name, status: item.json.status })) }; // API-Call (wird in nächstem Node gemacht) return [{ json: { batch: batchData, batchSize: items.length, timestamp: new Date().toISOString() } }]; ``` ```javascript Batch-Ergebnisse verarbeiten theme={null} // Batch-Response verarbeiten const batchResponse = $json.batchResponse; // Ergebnisse auf einzelne Items aufteilen const results = batchResponse.results.map((result, index) => { return { json: { originalId: $input.all()[index].json.id, processedId: result.id, status: result.status, processedAt: new Date().toISOString() } }; }); return results; ``` ## Rate Limit Management Batching reduziert die Request-Zahl direkt: Erlaubt eine API 100 Requests pro Minute und Ihr Workflow verarbeitet 1000 Items, brauchen Sie ohne Batching 1000 Requests (10 Minuten) — mit Batches à 10 Items nur 100 Requests (1 Minute). Automate hat keinen dedizierten Rate-Limit-Node. Das etablierte Muster für kontrollierte Request-Raten kombiniert den Loop Over Items Node mit einem Wait-Node in der Schleife: ``` Loop Over Items → Process Batch → Wait → zurück zu Loop Over Items ``` * Der Loop Over Items Node gibt pro Durchlauf einen Batch aus * Der Wait-Node pausiert nach jedem Batch für eine feste Zeit * Die Rückverbindung zum Loop Over Items Node startet den nächsten Batch **Beispiel:** Erlaubt die API 100 Requests pro Minute, wählen Sie `batchSize: 10` und eine Wait-Dauer von 6 Sekunden — so bleiben Sie bei maximal 100 Requests pro Minute. ## Parallele Batch-Verarbeitung Sie können Batches auf mehrere Branches verteilen und die Ergebnisse anschließend zusammenführen: ``` Loop Over Items → [Branch 1] → Process Batch 1 ┐ → [Branch 2] → Process Batch 2 ├→ Merge → [Branch 3] → Process Batch 3 ┘ ``` Achten Sie dabei auf Rate Limits — parallele Verarbeitung kann sie schneller erreichen. Die Parallelität begrenzen Sie mit einem Code-Node: ```javascript Code-Node für Parallelität theme={null} const batches = $input.all(); const maxParallel = 3; // Maximal 3 Batches gleichzeitig // Batches in Gruppen aufteilen const groups = []; for (let i = 0; i < batches.length; i += maxParallel) { groups.push(batches.slice(i, i + maxParallel)); } return groups.map(group => ({ json: { batches: group, groupIndex: groups.indexOf(group) } })); ``` ## Batch-Fehlerbehandlung ### Partielle Fehler Wenn einzelne Items in einem Batch fehlschlagen, trennen Sie erfolgreiche und fehlerhafte Items und behandeln letztere separat (Error Trigger): ```javascript Fehlerbehandlung theme={null} const batchResponse = $json.batchResponse; const results = []; const errors = []; batchResponse.results.forEach((result, index) => { if (result.success) { results.push({ json: { ...result.data, processed: true } }); } else { errors.push({ json: { originalItem: $input.all()[index].json, error: result.error, retry: true } }); } }); // Erfolgreiche Items zurückgeben return results; // Fehlerhafte Items separat behandeln (Error Trigger) ``` ### Retry-Logik für Batches Fehlgeschlagene Batches versuchen Sie erneut (`Process Batch → Error Trigger → Retry Logic → Process Batch`): ```javascript Retry mit Exponential Backoff theme={null} const maxRetries = 3; const retryCount = $workflow.staticData.retryCount || 0; if (retryCount < maxRetries) { const delay = Math.pow(2, retryCount) * 1000; // 1s, 2s, 4s // Wartezeit einbauen await new Promise(resolve => setTimeout(resolve, delay)); $workflow.staticData.retryCount = retryCount + 1; // Batch erneut verarbeiten return $input.all(); } else { // Max Retries erreicht, Fehler loggen throw new Error('Batch processing failed after retries'); } ``` ## Praxisbeispiel: E-Mail-Versand in Batches 100 E-Mails sollen versendet werden. Der Loop Over Items Node (`batchSize: 20`) erzeugt fünf Batches zu je 20 E-Mails; jeder Batch geht als ein Request an die E-Mail-API, ein Merge führt die Ergebnisse für das Success/Error-Tracking zusammen: ```json HTTP Request an E-Mail-API theme={null} { "method": "POST", "url": "https://api.email-service.com/batch", "body": { "emails": "={{ $input.all().map(item => item.json) }}" } } ``` ## Best Practices * **Batch-Größe optimieren:** an API-Limits, Verarbeitungszeit, Memory-Verfügbarkeit und Rate Limits ausrichten. * **Fehlerbehandlung:** partielle Fehler behandeln, Retry-Logik für fehlgeschlagene Batches, Fehler-Logging. * **Rate Limits respektieren:** mit Loop Over Items + Wait-Node drosseln, Backoff implementieren, Request-Rate überwachen. * **Monitoring:** Batch-Größe, Verarbeitungszeit und Fehlerrate im Blick behalten. * **Memory-Management:** keine zu großen Batches, Ergebnisse früh ausgeben, unnötige Daten entfernen. * **Testing:** mit verschiedenen Batch-Größen, Edge Cases (leere und sehr große Batches) und Fehler-Szenarien testen. ## Checkliste * [ ] Batch-Größe ist optimiert für API-Limits * [ ] Rate Limits werden eingehalten * [ ] Fehlerbehandlung ist implementiert * [ ] Retry-Logik für fehlgeschlagene Batches * [ ] Memory-Verbrauch ist akzeptabel * [ ] Performance wird überwacht * [ ] Edge Cases wurden getestet ## Nächste Schritte Retry-Logik für fehlgeschlagene Batches implementieren. Batch-Verarbeitung für bessere Performance optimieren. Items effektiv verwalten. Batch-Workflows gründlich testen.