Batching

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:

Loop Over Items Konfiguration

{
  "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().

{
  "method": "POST",
  "url": "https://api.example.com/batch",
  "body": {
    "items": "={{ $input.all().map(item => item.json) }}"
  }
}

{
  "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:

Batch GET

{
  "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:

// 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()
  }
}];

// 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:

Code-Node für Parallelität

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):

Fehlerbehandlung

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):

Retry mit Exponential Backoff

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:

HTTP Request an E-Mail-API

{
  "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 Logic

Retry-Logik für fehlgeschlagene Batches implementieren.

Performance

Batch-Verarbeitung für bessere Performance optimieren.

Item Management

Items effektiv verwalten.

Testing

Batch-Workflows gründlich testen.

Grundlagen

Localmind anbinden

Workflows

Erweitert

Betrieb

Loop Over Items Node

Batch-Größe bestimmen

Batch-API-Calls

Batch POST Request

Batch GET Request

Code-Node für Batch-Verarbeitung

Rate Limit Management

Parallele Batch-Verarbeitung

Batch-Fehlerbehandlung

Partielle Fehler

Retry-Logik für Batches

Praxisbeispiel: E-Mail-Versand in Batches

Best Practices

Checkliste

Nächste Schritte

Retry Logic

Performance

Item Management

Testing

​Loop Over Items Node

​Batch-Größe bestimmen

​Batch-API-Calls

​Batch POST Request

​Batch GET Request

​Code-Node für Batch-Verarbeitung

​Rate Limit Management

​Parallele Batch-Verarbeitung

​Batch-Fehlerbehandlung

​Partielle Fehler

​Retry-Logik für Batches

​Praxisbeispiel: E-Mail-Versand in Batches

​Best Practices

​Checkliste

​Nächste Schritte

Retry Logic

Performance

Item Management

Testing

Loop Over Items Node

Batch-Größe bestimmen

Batch-API-Calls

Batch POST Request

Batch GET Request

Code-Node für Batch-Verarbeitung

Rate Limit Management

Parallele Batch-Verarbeitung

Batch-Fehlerbehandlung

Partielle Fehler

Retry-Logik für Batches

Praxisbeispiel: E-Mail-Versand in Batches

Best Practices

Checkliste

Nächste Schritte