> ## Documentation Index
> Fetch the complete documentation index at: https://docs.langdock.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Code

> Write JavaScript or Python code directly from within your workflow.

## Overview

Use the Code node to process workflow data directly with custom JavaScript or Python code. Choose it when standard nodes are not enough, for example for calculations, formatting, validation, file processing, or custom business logic.

<img src="https://mintcdn.com/langdock-34/cWyoB3RsITQmAUnM/images/workflows/nodes/code.jpg?fit=max&auto=format&n=cWyoB3RsITQmAUnM&q=85&s=34341587cc99e314a2275f9db1f888b9" alt="Code" width="1920" height="903" data-path="images/workflows/nodes/code.jpg" />

## When to Use Code Node

**Code nodes are perfect for:**

* Data transformations and formatting
* Mathematical calculations
* Custom business logic
* JSON parsing and manipulation
* Data validation and cleaning
* Date/time operations
* File processing with Python

**What code nodes are not ideal for:**

* AI analysis (use Agent node)
* External API calls (use HTTP Request node)
* Simple conditions (use Condition node)
* Long-running or interactive analysis (use Data Analysis)

## Configuration

**Language**: Choose whether to write your code in JavaScript or Python.

**Code Editor**: Write your transformation logic in the selected language in the code editor that opens when you select the Code node.

**Access Previous Nodes**: Outputs from previous nodes are available as variables in the Code node. The available variable names are shown at the top of the code editor. To use the Code node output later, see [Accessing Code Output](#accessing-code-output).

## Examples

### Calculate Statistics

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Access data from previous nodes
  const scores = agent.output.structured.scores || [];

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

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

  ```python Python theme={null}
  # Access data from previous 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"
      }

  # Calculate statistics
  average = sum(scores) / len(scores)
  print(f"Processed {len(scores)} scores")

  # Return result
  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"
  }
  ```
</CodeGroup>

### Validate and Clean Data

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Access form data
  const email = trigger.output.email || "";
  const amount = trigger.output.amount || 0;

  // Validate
  if (!email.includes("@")) {
    throw new Error("Invalid email format");
  }

  if (amount <= 0) {
    throw new Error("Amount must be greater than zero");
  }

  // Clean and return
  return {
    email: email.trim().toLowerCase(),
    amount: parseFloat(amount.toFixed(2)),
    validated: true
  };
  ```

  ```python Python theme={null}
  # Access form data
  trigger_output = trigger.get("output", {})
  email = trigger_output.get("email", "")
  amount = trigger_output.get("amount", 0)

  # Validate
  if "@" not in email:
      raise ValueError("Invalid email format")

  if amount <= 0:
      raise ValueError("Amount must be greater than zero")

  # Clean and return
  return {
      "email": email.strip().lower(),
      "amount": round(float(amount), 2),
      "validated": True
  }
  ```
</CodeGroup>

### Transform and Filter Arrays

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Access data from previous node
  const customers = trigger.output.customers || [];

  // Filter active customers
  const activeCustomers = customers.filter(c => c.status === "active");

  // Transform data
  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
  };
  ```

  ```python Python theme={null}
  # Access data from previous node
  customers = trigger.get("output", {}).get("customers", [])

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

  # Transform data
  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"])
  }
  ```
</CodeGroup>

### Date Operations

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Access event data
  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("en-US", {
        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
  };
  ```

  ```python Python theme={null}
  from datetime import datetime, timezone

  # Access event data
  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"]])
  }
  ```
</CodeGroup>

### JSON Processing

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Nested JSON from API response
  const apiResponse = http_request.output || {};

  // Extract and flatten nested data
  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 || "Unknown",
    isActive: user.status === "active"
  }));

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

  ```python Python theme={null}
  # Nested JSON from API response
  api_response = http_request.get("output", {})

  # Extract and flatten nested data
  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", "Unknown"),
          "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"]])
  }
  ```
</CodeGroup>

### Aggregate and Summarize

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Sales data from previous node
  const sales = http_request.output.sales || [];

  // Group by category
  const byCategory = {};
  sales.forEach(sale => {
    const cat = sale.category || "Other";
    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);
  });

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

  // Sort by revenue
  summary.sort((a, b) => parseFloat(b.totalRevenue) - parseFloat(a.totalRevenue));

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

  ```python Python theme={null}
  # Sales data from previous node
  sales = http_request.get("output", {}).get("sales", [])

  # Group by category
  by_category = {}
  for sale in sales:
      category = sale.get("category") or "Other"
      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)

  # Calculate summary
  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()
  ]

  # Sort by revenue
  summary.sort(key=lambda row: float(row["totalRevenue"]), reverse=True)

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

### Create a File with Python

Files created by Python in the working directory are attached to the node output under `_files`.

```python Python theme={null}
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"Created CSV with {len(active_customers)} customers")

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

## Accessing Code Output

Use the Code node name to access returned values from JavaScript or Python in subsequent nodes:

```handlebars theme={null}
{{code_node_name.output.customer}}
{{code_node_name.output.total}}
{{code_node_name.output.formatted_date}}
{{code_node_name.output.processed_items[0].name}}
```

Files created by Python in the working directory are available under `_files`:

```handlebars theme={null}
{{code_node_name.output._files[0]._metadata.name}}
```

## Language Capabilities

Code node capabilities depend on the selected language.

### JavaScript

JavaScript runs in a secure sandbox environment with built-in utility functions:

* **`ld.request()`**: Make HTTP requests
* **`ld.log()`**: Output debugging information
* **Data conversions**: CSV, Parquet, Arrow format conversions
* **Standard JavaScript**: JSON, Date, Math, Array, Object methods

<Card title="Complete Utilities Reference" icon="code" href="/en/using-langdock/guides/integrations/sandbox-utilities">
  View all available sandbox utilities including data conversions, SQL validation, cryptography, and more.
</Card>

### Python

Python runs in a sandboxed environment without internet access.

* Use top-level `return` to set the node output
* Use `print()` to write logs
* Use preinstalled data and document libraries such as pandas, numpy, openpyxl, and pypdf
* Access previous node outputs as variables when their slugs are valid Python identifiers
* Read workflow attachments from the working directory
* Save files in the working directory to expose them under `_files`
* Run without internet access

The JavaScript `ld.*` utilities are not available in Python.

## Best Practices

<AccordionGroup>
  <Accordion title="Return Structured Objects">
    Return data as objects for easy access in later nodes. This makes it simple to reference specific values in subsequent nodes using dot notation.
  </Accordion>

  <Accordion title="Handle Missing Data">
    Use `||`, optional chaining (`?.`), or Python `.get()` to provide default values and prevent errors when data is undefined or null.
  </Accordion>

  <Accordion title="Use Error Handling">
    Wrap risky operations in `try/catch` for JavaScript or `try/except` for Python. This helps prevent workflow failures and provides meaningful error messages.
  </Accordion>

  <Accordion title="Keep It Simple">
    Complex logic might be better in an Agent node. Use code nodes for straightforward transformations and calculations, not for tasks requiring intelligence or context understanding.
  </Accordion>

  <Accordion title="Add Comments">
    Document what your code does for future reference. Clear comments help you and your team understand the logic when revisiting the workflow later.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Agent" icon="brain" href="/en/using-langdock/workflows/nodes/agent-node">
    Use AI for intelligent processing
  </Card>

  <Card title="HTTP Request" icon="globe" href="/en/using-langdock/workflows/nodes/http-request-node">
    Fetch external data
  </Card>

  <Card title="Data Analysis" icon="chart-bar" href="/en/using-langdock/chat/tools/data-analysis">
    Analyze data with an Agent
  </Card>
</CardGroup>