# Human

> Human node for pausing a process and assigning a task for human review, approval, or input.

The Human node pauses the process and assigns a task to a person, then resumes the process once they complete it. Use it when a process needs human review, approval, or input before it can continue.

## When to use Human vs Decision

Use the **Human** node when a person needs to review information and respond before the process continues. Use the [Decision](node-decision.md) node when the branch can be resolved automatically from existing data, without human involvement.

The Human node routes on the assignee's chosen outcome through its own output handles. Reach for a Decision when the branch follows from existing data instead of a person's choice.

## Human node types

The task presented to the human can be created via two mechanisms: **Quick form** and **Action app**.

### Quick form

Build and debug a lightweight form directly on the node. You define the fields the assignee sees, the inputs they need to provide and the outcomes they can choose. This is the default and the best fit for approvals and straightforward data collection.

### Action app

Action apps provide a richer, fully customized interface for the task assigned to the human. They can be built visually in UiPath App Studio or Studio Web, or as a Coded Action App—a custom React or Angular application. A coded app is selected under **Action App**, and its inputs are mapped at configuration time.
Refer to [About Coded Action Apps](../../../../apps/automation-cloud/latest/user-guide-ca/about-coded-action-apps.md).

| | Quick form | Action app |
|---|---|---|
| UI defined | On the node, versioned with the process | Separate app, deployed to Orchestrator |
| Reuse across processes | Yes, by copying and pasting JSON | Yes |
| Cost | No additional units, no Apps dependency | Requires app deployment |
| Layout | Allows multi-column, multi-width layouts, [Field behavior](../../../../action-center/automation-cloud/latest/user-guide/quick-form-tasks.md#field-behavior) | Full control |
| Data at render time | Bound process variables/expressions only | SDK: assets, buckets, connections, Data Fabric, trigger processes |
| Testing | Inline debug from canvas | Build → deploy → run |
| Build skills required | None | App Studio, or React/Angular for coded Apps |

:::tip
Start with a Quick form. Move to an Action app when you need to reuse the same interface across processes, show data the process does not already carry, or build a UI a form cannot express.
:::

Building the app itself is covered in the Action Apps documentation. From this point onward, this page covers the **Quick form** task type. For a hands-on walkthrough, refer to [Add human approval to a workflow](add-human-approval.md).
 
## Configuration

![Human node properties panel showing Assignment criteria set to Round Robin with a group search field, a Schema with four fields and Approve/Reject outcomes, and Delivery channels checkboxes for Slack, Microsoft Teams, Email, and Action Center.](https://dev-assets.cms.uipath.com/assets/images/maestro/node-human-configuration-panel-79242253.png)

| Field | Required | Default | Description |
|---|---|---|---|
| **Assignment criteria** | Yes | **Single User** | Controls how the Human node picks the person who gets the task. Choose between Single User, All users, Round Robin, Workload, or Custom. |
| **Schema** | Yes | Submit outcome | Form structure, including fields the assignee sees or fills in and outcomes they can select. Refer to [Schema](#schema) for the full structure. |
| **Delivery Channels** | — | Set at tenant level | Read-only on the node — the available channels are inherited from tenant-level configuration and shown as disabled checkboxes. Refer to [Delivery channels](#delivery-channels) for details. |
| **Task title** | No | None | Title shown to the assignee in their task list. |
| **Priority** | No | None | Priority shown in Action Center: **Low**, **Medium**, or **High**. |
| **Labels** | No | None | Comma-separated labels for organizing tasks, for example `finance,approval`. |

## Assignment criteria

Assignment criteria controls which person or people receive the task. Selecting a criterion changes the second field to match — a user picker for Single User, a group picker for the group-based criteria.

| **Criteria** | **Who gets the task** | **Use it when** |
|---|---|---|
| **Single User** | One named person. | A specific individual owns this decision — a named approver, a single reviewer |
| **All users** | Every member of the group at once. The first person to complete it closes the task for everyone. | You care about speed over ownership. Whoever is free picks it up |
| **Workload** | The one group member with the fewest open tasks | You want the queue spread evenly across a team |
| **Round Robin** | Group members in turn, cycling through the membership list | You want each member to take an equal share regardless of how fast they work |
| **Custom** | The member with the fewest open tasks, chosen from a list of users you supply at runtime rather than from a group's full membership. | Eligibility changes per run — skipping people who are out of office, off shift, or outside the right role or region. |

### Requirements and limits
 
:::important
**Workload and Round Robin require a local group.** Active Directory groups are rejected for both. Use **Single User** or **All users** if your assignees are in an Active Directory (AD) group.
:::

**In debug, group assignment does not work from a personal workspace.** Debug runs create the task in your personal workspace, which group members cannot access — so the task is created but stays **Unassigned**, and no notifications go out. This is expected, not a defect. Deploy the solution to a shared folder to test group assignment properly. Single-user assignment works normally in debug.

**Errors you may see:**
 
| Error | Meaning |
|---|---|
| `NoUsersFoundInLocalGroup` | The selected group has no members. |
| `NoEligibleUsersFoundInGroup` | Every member was excluded, so there is nobody left to assign to. |

## Schema

The Schema defines what the assignee sees and what they return to the process. It has two parts: fields and outcomes.

![Schema editor showing the Amount Requested, Amount Approved, Agent Confidence Score, and Reason fields, with the Amount Approved and Reason fields marked with a Variable badge, and Approve/Reject outcomes.](https://dev-assets.cms.uipath.com/assets/images/maestro/node-human-schema-fields-d07d844b.png)

### Fields

The Schema can also be edited directly as JSON. Refer to [Quick Form tasks](../../../../action-center/automation-cloud/latest/user-guide/quick-form-tasks.md) for the full JSON schema reference. In the Form view, each field has these settings:
 
| Setting | What it does |
|---|---|
| **Label** | The display name shown to the assignee. |
| **Type** | Controls validation and how the input renders. Available types: Text, Number, Decimal number, Date, Date and time, Yes or no, Single select, Multi-select, Array, File. |
| **Binding** | An expression that pre-populates the field, for example `$vars.requestAmt`. Accepts any workflow expression, not only a variable reference. |
| **Editable** | The padlock next to the value. Locked means the assignee can read the value but not change it. |
| **Variable** | Shown as an **(x)** badge next to the field name. Auto-derived from the Label for Output and In/Out fields, exposing the value as a named process variable in addition to `$vars.<nodeName>.output.<fieldId>`. Not present on Input fields. |
 
#### Field directions
 
Fields carry data into and out of the task. Each field has a direction.

- **Input** fields are read-only context for the assignee, bound to a process value, for example `$vars.start.output.employeeName`.
- **Output** fields are filled in by the assignee and returned to the process.
- **In/Out** fields do both: they show the assignee a process value as a starting point, and the assignee can edit it before it's returned to the process.

A field's *direction* is not a separate setting. It is the result of two controls: whether the field is **bound** determines if it arrives pre-filled, and whether it is **unlocked** determines if the assignee can change it.
 
| Binding | Padlock | Direction | Assignee sees | Editable & returned |
|---|---|---|---|---|
| Set | Locked 🔒 | **Input** | The bound value | No |
| Set | Unlocked 🔓 | **In/Out** | The bound value | Yes |
| None | Unlocked 🔓 | **Output** | An empty field | Yes |
| None | Locked 🔒 | *Not valid* | An empty field | No |

### Outcomes

Outcomes are the buttons the assignee uses to complete the task, for example **Approve** and **Reject**. The default schema has a single **Submit** outcome. The first outcome is marked as the primary action.

Each outcome adds its own output handle to the node. When the assignee selects an outcome, the process continues from that outcome's handle, so you can route each outcome to a different path. Refer to [Branching on the result](#branching-on-the-result).

### Delivery channels
 
Tasks are delivered to:

- **Action Center**
- **Email**
- **Slack**
- **Microsoft Teams**

:::important
Delivery channels can only be modified at the tenant level, from **Admin settings**. The checkboxes on the node are disabled and reflect the current tenant configuration.
:::

Slack and Microsoft Teams require an Integration Service connection. Refer to [Actionable notifications](../../../../action-center/automation-cloud/latest/user-guide/actionable-notifications.md) for connector setup.

## Output

Access the node's output at `$vars.<nodeName>.output` and the selected outcome at `$vars.<nodeName>.status`.

### output

The task result: an object holding the values the assignee submitted, keyed by output field. Read a single field with `$vars.<nodeName>.output.<fieldId>`. The object also carries an `Action` property set to the selected outcome.

### status

The outcome the assignee selected, for example `Approve`. Branch on this value to route the process.

## Branching on the result

Each outcome you define adds an output handle to the Human node. When the assignee completes the task, the process continues from the handle for the outcome they selected. Connect each outcome handle to the node that should run for that path. You don't need a Decision node to split on the outcome.

```
Human
  ├─ Approve → continue processing
  └─ Reject  → notify the requester and terminate
```

Read a submitted field in any downstream node with `$vars.<nodeName>.output.<fieldId>`:

```javascript
// In a Script node on one of the outcome paths
return $vars.approval.output.comment;
```

The selected outcome is also available as `$vars.<nodeName>.status` if you need it in an expression.

## Common issues

### Task does not appear for the assignee

Verify the assignee, whether a user or a group, is correct and has access to Action Center.

### An output value is missing

Confirm the field is defined in the Schema with direction **Output**.

### An outcome routes to the wrong path

Confirm each outcome's output handle is connected to the node you intend. Each outcome you define in the schema has its own handle on the Human node.

## Notes

:::note
To test without a real assignee, use **Mock output** to simulate a `status` and `output` response. Refer to [Add human approval to a workflow](add-human-approval.md) for the steps.
:::

- If the assignee is a group, any member of that group can claim and complete the task.
- For a richer interface than a form, back the task with an Action app instead of a Quick form.

## Related pages

- [Add human approval to a workflow](add-human-approval.md)
- [Decision](node-decision.md)
- [Terminate](node-terminate.md)
- [Quick Form tasks](../../../../action-center/automation-cloud/latest/user-guide/quick-form-tasks.md)