---
title: "Code"
description: "Execute custom Python or JavaScript for data processing"
icon: "code"
---

The Code node executes custom Python or JavaScript to handle complex data transformations, calculations, and logic within your workflow. Use it when preset nodes aren't sufficient for your specific processing needs.

<Frame caption="Code node configuration interface">
  <img src="https://assets-docs.dify.ai/dify-enterprise-mintlify/en/guides/workflow/node/9969aa1bc1912aebe366f5d8f5dde296.png" alt="Code node interface" />
</Frame>

## Configuration

Define **Input Variables** to access data from other nodes in your workflow, then reference these variables in your code. Your function must return a dictionary containing the **Output Variables** you've declared.

```python
def main(input_variable: str) -> dict:
    # Process the input
    result = input_variable.upper()
    return {
        'output_variable': result
    }
```

## Language Support

Choose between **Python** and **JavaScript** based on your needs and familiarity. Both languages run in secure sandboxes with access to common libraries for data processing.

<Tabs>
  <Tab title="Python">
    Python includes standard libraries like `json`, `math`, `datetime`, and `re`. Ideal for data analysis, mathematical operations, and text processing.
    
    ```python
    def main(data: list) -> dict:
        import json
        import math
        
        average = sum(data) / len(data)
        return {'result': math.ceil(average)}
    ```
  </Tab>
  
  <Tab title="JavaScript">
    JavaScript provides standard built-in objects and methods. Good for JSON manipulation and string operations.
    
    ```javascript
    function main(data) {
        const processed = data.map(item => item.toUpperCase());
        return { result: processed };
    }
    ```
  </Tab>
</Tabs>

## Error Handling and Retries

Configure automatic retry behavior for failed code executions and define fallback strategies when code encounters errors.

<Frame caption="Error handling configuration options">
  <img src="https://assets-docs.dify.ai/2024/12/58f392734ce44b22cd8c160faf28cd14.png" alt="Code Error handling" />
</Frame>

**Retry Settings** allow up to 10 automatic retries with configurable intervals (maximum 5000ms). Enable this for handling temporary processing issues.

**Error Handling** lets you define fallback paths when code execution fails, allowing your workflow to continue running even when the code encounters problems.

<Frame caption="Retry configuration interface">
  <img src="https://assets-docs.dify.ai/2024/12/9fdd5525a91dc925b79b89272893becf.png" alt="Retry settings" />
</Frame>

## Output Validation and Limits

Code outputs are automatically validated with strict limits:
- **Strings**: Maximum length of 80,000 characters, null bytes are removed
- **Numbers**: Range from -999999999 to 999999999, floats limited to 10 decimal places
- **Objects/Arrays**: Maximum depth of 5 levels to prevent complex nested structures

These limits ensure performance and prevent memory issues in workflows.

## Security Considerations

Code executes in a strict sandbox that prevents file system access, network requests, and system commands. This maintains security while providing programming flexibility.

Some operations are automatically blocked for security reasons. Avoid attempting to access system files or execute potentially dangerous operations:

<Frame caption="Security filtering by Cloudflare WAF">
  <img src="https://assets-docs.dify.ai/2024/12/ad4dc065c4c567c150ab7fa7bfd123a3.png" alt="Cloudflare WAF blocking" />
</Frame>

If your code isn't saving, check your browser's Network tab - security filters may be blocking potentially dangerous operations.

## Dependencies Support

Code nodes support external dependencies for both Python and JavaScript:

```python
# Python: Import numpy, pandas, requests, etc.
import numpy as np
import pandas as pd

def main(data: list) -> dict:
    df = pd.DataFrame(data)
    return {'mean': float(np.mean(df['values']))}
```

```javascript
// JavaScript: Import lodash, moment, etc.
const _ = require('lodash');

function main(data) {
    return { unique: _.uniq(data) };
}
```

Dependencies are pre-installed in the sandbox environment. Check the available packages list in your Dify installation.

## Self-Hosted Setup

For self-hosted Dify installations, start the sandbox service for secure code execution:

```bash
docker-compose -f docker-compose.middleware.yaml up -d
```

The sandbox service requires Docker and isolates code execution from your main system for security.

## Common Use Cases

**Data Parsing** - Extract specific values from complex JSON structures returned by APIs or other nodes.

**Mathematical Operations** - Perform calculations, statistical analysis, or data aggregation that preset nodes can't handle.

**Data Transformation** - Convert data formats, combine multiple data sources, or restructure information for downstream processing.

**Conditional Logic** - Implement complex decision-making logic that goes beyond simple if-else conditions.