# Script

> Script node reference: configuration, environment, and JavaScript examples.

## What it does

Runs JavaScript code and passes the return value to downstream nodes.

## Configuration reference

| Field | Required | Default | Description |
|---|---|---|---|
| **Script** | Yes | None | JavaScript code to execute. Must contain a `return` statement; the returned value becomes this node's output. |

## The JavaScript environment

Scripts run in an isolated runtime and have access to:

- **`$vars`** — the flow's variable scope. Access upstream node output via `$vars.<nodeName>.<property>`.
- **`metadata`** — flow execution metadata
- **Standard JavaScript built-ins** — such as `JSON`, `Math`, `Date`, `Array`, `Object`, `String`, `Number`, `RegExp`, `Error`, `Promise`, `URL`, `URLSearchParams`, and the timer functions.

For security, the runtime blocks network APIs (`fetch`, `XMLHttpRequest`, `WebSocket`), dynamic code execution (`eval`, `Function`), and storage APIs (`indexedDB`, `caches`). To call an external API, use the HTTP Request node instead.

Scripts are meant for fast, in-memory logic: keep them quick and avoid processing very large payloads, which can exceed runtime limits or time out.

### Accessing upstream node output

Use `$vars.<nodeName>.<property>` where `<nodeName>` is the node's variable name (shown in the properties panel):

```javascript
// Access HTTP Request node response
const body = $vars.httpRequest1.output.body;
const status = $vars.httpRequest1.output.statusCode;

// Access a flow variable
const count = $vars.myVariable;
```

### Return value

The script must return a value. The returned value becomes the node's output, accessible downstream as `$vars.<nodeName>.output`:

```javascript
return {
  message: "Processed",
  count: items.length
};
```

## Inputs and outputs

### Input

The Script node can access any upstream variable via `$vars`. It does not have a typed input schema — anything in `$vars` is available.

### Output

**On success** — `$vars.<nodeName>.output`:

The return value of the script. Shape depends on what the script returns.

**On failure** (when an error handle is connected) — `$vars.<nodeName>.error`:

```json
{
  "code": "string",
  "message": "string",
  "detail": "string",
  "category": "string",
  "status": 0
}
```

## Generate scripts with AI

The **magic wand** icon above the script editor accepts a plain-language description of what you want and generates the JavaScript for you. This is useful for accessing an upstream node's output or writing a quick transformation without looking up the exact `$vars` syntax.

![Script node properties panel with the AI generation (magic wand) icon highlighted above the code editor.](https://dev-assets.cms.uipath.com/assets/images/maestro/flow-magic-wand-f3d3f752.webp)

## Examples

### Example 1 — Set a process variable

```javascript
// Set a variable that downstream nodes can reference
return {
  orderTotal: $vars.httpRequest1.output.body.price * $vars.httpRequest1.output.body.quantity,
  currency: "USD"
};
```

Downstream nodes access the values as `$vars.script1.output.orderTotal` and `$vars.script1.output.currency`.

### Example 2 — Process an HTTP response

```javascript
const data = $vars.httpRequest1.output.body;

return {
  title: data.title,
  userId: data.userId
};
```

### Example 3 — Conditional logic

```javascript
const status = $vars.httpRequest1.output.statusCode;

if (status === 200) {
  return { success: true, data: $vars.httpRequest1.output.body };
} else {
  return { success: false, statusCode: status };
}
```

### Example 4 — Transform an array

```javascript
const items = $vars.fetchItems1.output.body;

return {
  count: items.length,
  names: items.map(item => item.name)
};
```

## When to use this vs Data Transform

| Use Script when... | Use Data Transform when... |
|---|---|
| You need full JavaScript logic — loops, conditionals, string manipulation | You need a simple field mapping or no-code transformation |
| You want to compute something from upstream node output | You want a visual mapper without writing code |
| The transformation is complex or stateful | The transformation is a straightforward reshape |

## Related pages

- **[Variables and data flow](variables-and-data-flow.md)** — `$vars`, expression syntax, variable scoping
- **[HTTP Request node](node-http-request.md)** — typical upstream data source
- **[Decision node](node-decision.md)** — branch based on Script output