Code

Überblick

Mit dem Code-Node verarbeitest du Workflow-Daten direkt mit eigenem JavaScript- oder Python-Code. Nutze ihn, wenn Standard-Nodes nicht ausreichen, zum Beispiel für Berechnungen, Formatierungen, Validierungen, Dateiverarbeitung oder individuelle Geschäftslogik.

Wann du den Code-Node verwenden solltest

Die Code-Node ist perfekt für:

Datentransformationen und Formatierung
Mathematische Berechnungen
Benutzerdefinierte Geschäftslogik
JSON-Parsing und Manipulation
Datenvalidierung und -bereinigung
Datums-/Zeitoperationen
Dateiverarbeitung mit JavaScript und Python

Die Code-Node ist nicht ideal für:

KI-Analyse (verwende Agent-Node)
Externe API-Aufrufe (verwende HTTP-Request-Node)
Einfache Bedingungen (verwende Condition-Node)
Lange oder interaktive Analysen (verwende Datenanalyse)

Konfiguration

Sprache: Wähle aus, ob du deinen Code in JavaScript oder Python schreiben möchtest. Code-Editor: Schreibe deine Transformationslogik in der ausgewählten Sprache im Code-Editor, der sich öffnet, wenn du den Code-Node auswählst Auf vorherige Nodes zugreifen: Outputs von vorherigen Nodes sind als Variablen im Code-Node verfügbar. Die verfügbaren Variablennamen werden oben im Code-Editor angezeigt. Nur vorgelagerte Nodes, deren Slugs in deinem Code vorkommen, werden geladen. Der Zugriff über data oder das dynamische Nachschlagen von Outputs statt über ihren Slug lädt stattdessen alle vorgelagerten Outputs. Wie du den Output des Code-Nodes später verwendest, findest du unter Auf Code-Output zugreifen.

Beispiele

Statistiken berechnen

// Zugriff auf Daten von vorherigen Nodes
const scores = agent.output.structured.scores || [];

// Statistiken berechnen
const average = scores.reduce((a, b) => a + b, 0) / scores.length;
const max = Math.max(...scores);
const min = Math.min(...scores);

// Ergebnis zurückgeben
return {
  average_score: average.toFixed(2),
  highest_score: max,
  lowest_score: min,
  grade: average >= 90 ? "A" : average >= 80 ? "B" : "C"
};

# Zugriff auf Daten von vorherigen Nodes
agent_output = agent.get("output", {})
scores = agent_output.get("structured", {}).get("scores", [])

if not scores:
    return {
        "average_score": 0,
        "highest_score": None,
        "lowest_score": None,
        "grade": "N/A"
    }

# Statistiken berechnen
average = sum(scores) / len(scores)
print(f"{len(scores)} Scores verarbeitet")

# Ergebnis zurückgeben
return {
    "average_score": round(average, 2),
    "highest_score": max(scores),
    "lowest_score": min(scores),
    "grade": "A" if average >= 90 else "B" if average >= 80 else "C"
}

Daten validieren und bereinigen

// Zugriff auf Formulardaten
const email = trigger.output.email || "";
const amount = trigger.output.amount || 0;

// Validieren
if (!email.includes("@")) {
  throw new Error("Ungültiges E-Mail-Format");
}

if (amount <= 0) {
  throw new Error("Betrag muss größer als null sein");
}

// Bereinigen und zurückgeben
return {
  email: email.trim().toLowerCase(),
  amount: parseFloat(amount.toFixed(2)),
  validated: true
};

# Zugriff auf Formulardaten
trigger_output = trigger.get("output", {})
email = trigger_output.get("email", "")
amount = trigger_output.get("amount", 0)

# Validieren
if "@" not in email:
    raise ValueError("Ungültiges E-Mail-Format")

if amount <= 0:
    raise ValueError("Betrag muss größer als null sein")

# Bereinigen und zurückgeben
return {
    "email": email.strip().lower(),
    "amount": round(float(amount), 2),
    "validated": True
}

Arrays transformieren und filtern

// Zugriff auf Daten von vorherigem Node
const customers = trigger.output.customers || [];

// Aktive Kunden filtern
const activeCustomers = customers.filter(c => c.status === "active");

// Daten transformieren
const processed = activeCustomers.map(customer => ({
  id: customer.id,
  name: `${customer.firstName} ${customer.lastName}`.trim(),
  email: customer.email.toLowerCase(),
  tier: customer.totalSpent > 1000 ? "premium" : "standard"
}));

return {
  customers: processed,
  total: processed.length,
  premiumCount: processed.filter(c => c.tier === "premium").length
};

# Zugriff auf Daten von vorherigem Node
customers = trigger.get("output", {}).get("customers", [])

# Aktive Kunden filtern
active_customers = [
    customer for customer in customers
    if customer.get("status") == "active"
]

# Daten transformieren
processed = [
    {
        "id": customer.get("id"),
        "name": f"{customer.get('firstName', '')} {customer.get('lastName', '')}".strip(),
        "email": customer.get("email", "").lower(),
        "tier": "premium" if customer.get("totalSpent", 0) > 1000 else "standard"
    }
    for customer in active_customers
]

return {
    "customers": processed,
    "total": len(processed),
    "premiumCount": len([c for c in processed if c["tier"] == "premium"])
}

Datumsoperationen

// Zugriff auf Event-Daten
const events = trigger.output.events || [];
const now = new Date();

const processedEvents = events.map(event => {
  const eventDate = new Date(event.date);
  const daysUntil = Math.ceil((eventDate - now) / (1000 * 60 * 60 * 24));

  return {
    title: event.title,
    date: eventDate.toISOString(),
    formatted: eventDate.toLocaleDateString("de-DE", {
      weekday: "long",
      year: "numeric",
      month: "long",
      day: "numeric"
    }),
    daysUntil: daysUntil,
    isUpcoming: daysUntil >= 0,
    isThisWeek: daysUntil >= 0 && daysUntil <= 7
  };
});

return {
  events: processedEvents,
  upcomingCount: processedEvents.filter(e => e.isUpcoming).length,
  thisWeekCount: processedEvents.filter(e => e.isThisWeek).length
};

from datetime import datetime, timezone

# Zugriff auf Event-Daten
events = trigger.get("output", {}).get("events", [])
now = datetime.now(timezone.utc)

processed_events = []
for event in events:
    event_date = datetime.fromisoformat(event["date"].replace("Z", "+00:00"))
    days_until = (event_date.date() - now.date()).days

    processed_events.append({
        "title": event.get("title"),
        "date": event_date.isoformat(),
        "formatted": event_date.strftime("%A, %B %d, %Y"),
        "daysUntil": days_until,
        "isUpcoming": days_until >= 0,
        "isThisWeek": 0 <= days_until <= 7
    })

return {
    "events": processed_events,
    "upcomingCount": len([e for e in processed_events if e["isUpcoming"]]),
    "thisWeekCount": len([e for e in processed_events if e["isThisWeek"]])
}

JSON-Verarbeitung

// Verschachteltes JSON von API-Response
const apiResponse = http_request.output || {};

// Verschachtelte Daten extrahieren und vereinfachen
const users = apiResponse.data?.users || [];

const flattened = users.map(user => ({
  id: user.id,
  name: `${user.first_name || ""} ${user.last_name || ""}`.trim(),
  email: user.contact?.email || "",
  city: user.address?.city || "Unbekannt",
  isActive: user.status === "active"
}));

return {
  users: flattened,
  total: flattened.length,
  activeCount: flattened.filter(u => u.isActive).length
};

# Verschachteltes JSON von API-Response
api_response = http_request.get("output", {})

# Verschachtelte Daten extrahieren und vereinfachen
users = api_response.get("data", {}).get("users", [])

flattened = [
    {
        "id": user.get("id"),
        "name": f"{user.get('first_name', '')} {user.get('last_name', '')}".strip(),
        "email": user.get("contact", {}).get("email", ""),
        "city": user.get("address", {}).get("city", "Unbekannt"),
        "isActive": user.get("status") == "active"
    }
    for user in users
]

return {
    "users": flattened,
    "total": len(flattened),
    "activeCount": len([user for user in flattened if user["isActive"]])
}

Aggregieren und Zusammenfassen

// Verkaufsdaten von vorherigem Node
const sales = http_request.output.sales || [];

// Nach Kategorie gruppieren
const byCategory = {};
sales.forEach(sale => {
  const cat = sale.category || "Sonstiges";
  if (!byCategory[cat]) {
    byCategory[cat] = { total: 0, count: 0, items: [] };
  }
  byCategory[cat].total += sale.amount || 0;
  byCategory[cat].count += 1;
  byCategory[cat].items.push(sale);
});

// Zusammenfassung berechnen
const summary = Object.entries(byCategory).map(([category, data]) => ({
  category,
  totalRevenue: data.total.toFixed(2),
  orderCount: data.count,
  averageOrder: (data.total / data.count).toFixed(2)
}));

// Nach Umsatz sortieren
summary.sort((a, b) => parseFloat(b.totalRevenue) - parseFloat(a.totalRevenue));

return {
  summary: summary,
  topCategory: summary[0]?.category || "Keine",
  grandTotal: sales.reduce((sum, s) => sum + (s.amount || 0), 0).toFixed(2)
};

# Verkaufsdaten von vorherigem Node
sales = http_request.get("output", {}).get("sales", [])

# Nach Kategorie gruppieren
by_category = {}
for sale in sales:
    category = sale.get("category") or "Sonstiges"
    if category not in by_category:
        by_category[category] = {"total": 0, "count": 0, "items": []}

    by_category[category]["total"] += sale.get("amount", 0)
    by_category[category]["count"] += 1
    by_category[category]["items"].append(sale)

# Zusammenfassung berechnen
summary = [
    {
        "category": category,
        "totalRevenue": f"{data['total']:.2f}",
        "orderCount": data["count"],
        "averageOrder": f"{data['total'] / data['count']:.2f}"
    }
    for category, data in by_category.items()
]

# Nach Umsatz sortieren
summary.sort(key=lambda row: float(row["totalRevenue"]), reverse=True)

return {
    "summary": summary,
    "topCategory": summary[0]["category"] if summary else "Keine",
    "grandTotal": f"{sum(sale.get('amount', 0) for sale in sales):.2f}"
}

Datei mit JavaScript erstellen

JavaScript kann Workflow-Dateien erzeugen, indem es ein files-Array zurückgibt. Jeder Eintrag muss fileName, mimeType und entweder text (für Text-, CSV- oder JSON-Inhalte) oder base64 (für binäre Inhalte) enthalten. Die Laufzeit lädt die Dateien hoch und hängt sie am Node-Output unter _files an.

JavaScript

const customers = trigger.output.customers || [];
const activeCustomers = customers.filter((c) => c.status === "active");

const csv = [
  ["id", "email"],
  ...activeCustomers.map((c) => [c.id, (c.email || "").toLowerCase()]),
]
  .map((row) => row.map((cell) => `"${String(cell).replaceAll('"', '""')}"`).join(","))
  .join("\n");

return {
  active_count: activeCustomers.length,
  files: [
    {
      fileName: "active_customers.csv",
      mimeType: "text/csv",
      text: csv,
    },
  ],
};

Dateien aus vorherigen Nodes lesen

Dateien aus vorherigen Nodes, zum Beispiel Formular-Uploads oder Action-Outputs, liegen im Python-Arbeitsverzeichnis bereit. Jedes Datei-Objekt enthält einen path, den du direkt an open() übergeben kannst, sowie den ursprünglichen Dateinamen unter _metadata.name.

Python

# Datei-Upload-Felder enthalten eine Liste von Datei-Objekten
files = trigger.get("output", {}).get("resume", [])

processed = []
for file in files:
    with open(file["path"], "rb") as f:
        content = f.read()

    processed.append({
        "name": file["_metadata"]["name"],
        "size_bytes": len(content)
    })

return {"files_processed": processed}

Datei mit Python erstellen

Dateien, die du mit Python im Arbeitsverzeichnis erstellst, werden dem Node-Output unter _files hinzugefügt.

Python

import csv

customers = trigger.get("output", {}).get("customers", [])
active_customers = [c for c in customers if c.get("status") == "active"]

with open("active_customers.csv", "w", newline="") as file:
    writer = csv.DictWriter(file, fieldnames=["id", "email"])
    writer.writeheader()

    for customer in active_customers:
        writer.writerow({
            "id": customer.get("id"),
            "email": customer.get("email", "").lower()
        })

print(f"CSV mit {len(active_customers)} Kunden erstellt")

return {
    "active_count": len(active_customers),
    "file_name": "active_customers.csv"
}

Auf Code-Output zugreifen

Verwende den Code-Node-Namen, um auf zurückgegebene Werte aus JavaScript oder Python in nachfolgenden Nodes zuzugreifen:

{{code_node_name.output.customer}}
{{code_node_name.output.total}}
{{code_node_name.output.formatted_date}}
{{code_node_name.output.processed_items[0].name}}

Dateien, die JavaScript zurückgibt oder die du mit Python im Arbeitsverzeichnis erstellst, sind unter _files verfügbar:

{{code_node_name.output._files[0]._metadata.name}}

Sprachfunktionen

Die Funktionen des Code-Nodes hängen von der ausgewählten Sprache ab.

JavaScript

JavaScript läuft in einer sicheren Sandbox-Umgebung mit integrierten Utility-Funktionen:

ld.request(): HTTP-Anfragen ausführen
ld.log(): Debugging-Informationen ausgeben
Datenkonvertierungen: CSV-, Parquet-, Arrow-Format-Konvertierungen
Datei-Erstellung: Gib ein files-Array zurück, um erzeugte Dateien unter _files bereitzustellen
Standard-JavaScript: JSON-, Date-, Math-, Array-, Object-Methoden

Vollständige Utilities-Referenz

Sieh dir alle verfügbaren Sandbox-Utilities an, einschließlich Datenkonvertierungen, SQL-Validierung, Kryptographie und mehr.

Python

Python läuft in einer isolierten Umgebung ohne Internetzugang.

Verwende return auf oberster Ebene, um den Node-Output festzulegen
Verwende print(), um Logs zu schreiben
Verwende vorinstallierte Daten- und Dokumentbibliotheken wie pandas, numpy, openpyxl und pypdf
Greife auf vorgelagerte Outputs als Variablen zu, wenn ihre Slugs in deinem Code vorkommen und gültige Python-Bezeichner sind
Lies Dateien aus vorherigen Nodes, indem du file["path"] an open() übergibst
Speichere Dateien im Arbeitsverzeichnis, um sie unter _files bereitzustellen
Läuft ohne Internetzugang

Die JavaScript-Utilities ld.* sind in Python nicht verfügbar.

Best Practices

Gib strukturierte Objekte zurück

Gib Daten als Objekte zurück für einfachen Zugriff in späteren Nodes. Das macht es einfach, spezifische Werte in nachfolgenden Nodes mit Punkt-Notation zu referenzieren.

Handle fehlende Daten

Verwende ||, Optional Chaining oder Python .get(), um Standardwerte bereitzustellen und Fehler zu verhindern, wenn Daten undefined oder null sind.

Verwende Error Handling

Umschließe riskante Operationen mit try/catch in JavaScript oder try/except in Python. Das hilft dir, Workflow-Fehler zu verhindern und aussagekräftige Fehlermeldungen bereitzustellen.

Halte es einfach

Komplexe Logik könnte in einem Agent-Node besser aufgehoben sein. Verwende Code-Nodes für unkomplizierte Transformationen und Berechnungen, nicht für Aufgaben, die Intelligenz oder Kontextverständnis erfordern.

Halte Inputs klein

Code-Nodes schlagen fehl, wenn die geladenen vorgelagerten Outputs 5 MiB überschreiten. Referenziere nur die Slugs, die du brauchst, da data und andere dynamische Zugriffe auf Outputs alle vorgelagerten Outputs laden.

Füge Kommentare hinzu

Dokumentiere, was dein Code macht, für zukünftige Referenz. Klare Kommentare helfen dir und deinem Team, die Logik zu verstehen, wenn der Workflow später erneut besucht wird.

Limits

Jeder Code-Node hat ein Limit von 5 MiB für die kombinierten Eingaben, die er von vorherigen Nodes erhält. Bevor dein Code ausgeführt wird, misst Langdock die Größe der vorgelagerten Outputs, deren Slugs in deinem Code vorkommen. Überschreiten diese 5 MiB, schlägt der Node mit einer Fehlermeldung fehl und dein Code wird nicht ausgeführt. Der Zugriff über data oder das dynamische Nachschlagen von Outputs statt über ihren Slug lädt stattdessen alle vorgelagerten Outputs. Deren gesamte Größe wird auf das Limit angerechnet. Häufige Ursachen:

Ein Loop-Node, der die Outputs vieler Iterationen in einem einzigen Array sammelt.
Ein vorgelagerter Node, der eine sehr große API-Antwort, Dateiinhalte oder einen großen Datensatz zurückgibt.
Tief verschachtelte Objekte, deren Größe nicht sicher gemessen werden kann.

Wenn du an dieses Limit stößt, kannst du Folgendes tun:

Verkleinere den Output des vorgelagerten Nodes, indem du filterst, zusammenfasst oder nur die benötigten Felder auswählst.
Verarbeite weniger Elemente pro Iteration in einem vorhergehenden Loop-Node.
Deaktiviere die Output-Sammlung im vorhergehenden Loop-Node, wenn du dessen aggregierte Ergebnisse nicht benötigst.

Nächste Schritte

Agent

Verwende KI für intelligente Verarbeitung

HTTP Request

Hole externe Daten ab

Datenanalyse

Analysiere Daten mit einem Agent

Erste Schritte

Chat

Skills

Dateien

Agenten

Workflows

Integrationen

Microsoft Plugins

Modelle & Limits

Anleitungen

Account

Ressourcen

Fehlerbehebung

Überblick

Wann du den Code-Node verwenden solltest

Konfiguration

Beispiele

Statistiken berechnen

Daten validieren und bereinigen

Arrays transformieren und filtern

Datumsoperationen

JSON-Verarbeitung

Aggregieren und Zusammenfassen

Datei mit JavaScript erstellen

Dateien aus vorherigen Nodes lesen

Datei mit Python erstellen

Auf Code-Output zugreifen

Sprachfunktionen

JavaScript

Vollständige Utilities-Referenz

Python

Best Practices

Limits

Nächste Schritte

Agent

HTTP Request

Datenanalyse

​Überblick

​Wann du den Code-Node verwenden solltest

​Konfiguration

​Beispiele

​Statistiken berechnen

​Daten validieren und bereinigen

​Arrays transformieren und filtern

​Datumsoperationen

​JSON-Verarbeitung

​Aggregieren und Zusammenfassen

​Datei mit JavaScript erstellen

​Dateien aus vorherigen Nodes lesen

​Datei mit Python erstellen

​Auf Code-Output zugreifen

​Sprachfunktionen

​JavaScript

Vollständige Utilities-Referenz

​Python

​Best Practices

​Limits

​Nächste Schritte

Agent

HTTP Request

Datenanalyse

Überblick

Wann du den Code-Node verwenden solltest

Konfiguration

Beispiele

Statistiken berechnen

Daten validieren und bereinigen

Arrays transformieren und filtern

Datumsoperationen

JSON-Verarbeitung

Aggregieren und Zusammenfassen

Datei mit JavaScript erstellen

Dateien aus vorherigen Nodes lesen

Datei mit Python erstellen

Auf Code-Output zugreifen

Sprachfunktionen

JavaScript

Python

Best Practices

Limits

Nächste Schritte