> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ingestly.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Call workflow
> Run another workflow as a reusable section on this document and use what it returns.
The call workflow action runs another workflow as a **reusable section** on the current document, waits for it to finish, and makes what it returned available to the nodes after it. Use it when several workflows need the same block of steps: build that block once as a callable workflow and call it from each.
It is a mid-graph action, not a handoff. The document stays where it is, and everything stays under one run.
Calling is different from forwarding. A [Forward output](/nodes/forward-output) hands a document off to another workflow as a **new document with its own run**, and nothing continues after it. A call runs another workflow's steps on **this** document, as part of **this** run, and continues afterwards with the result.
## Configuration
| Field | Type | Required | Description |
| -------------------- | --------------- | -------- | --------------------------------------------------- |
| **Workflow to call** | workflow picker | Yes | The section to run. Only callable workflows appear |
| **Field mappings** | mapping tree | Depends | One entry per field in the section's input contract |
### Workflow to call
A workflow is callable when it has a [Sub-workflow trigger](/nodes/sub-workflow-trigger) and at most one [Return output](/nodes/return). The picker lists only those, in the same environment, and never the workflow you are editing. A section without a return is a terminal stage: the call succeeds with an empty payload, so nothing placed after it can read section data. Because such a call produces nothing, the call node may also **end the branch** - it needs no outgoing connection. When the section does declare a return, the call must have one, so its result is actually used.
Highlight an option in the picker before choosing it and a preview of its inputs and returns appears below the list, so you can check whether a candidate section fits before you commit. Once a target is selected, an **Open** link next to the field opens that section's editor in a window over the current one, and the node's own toolbar carries the same action so you can reach the section without opening this editor at all.
The section opens as a full editor, not a preview: you can edit it, save it, and undo within it, and none of that touches the workflow underneath. Close it with **Close** or the Escape key to come back to exactly where you were, unsaved changes and all. If the section itself has unsaved changes, Ingestly asks before discarding them. Sections that call other sections keep stacking, so you can follow a chain down and close your way back up.
Ctrl-click (Cmd-click on a Mac) the **Open** link, or use **Open in a tab** inside the window, to work on the section in a tab of its own instead.
Pick **Create new section...** at the bottom of the list to scaffold an empty section, an unconfigured Sub-workflow trigger wired straight to a Return, without leaving this editor. Ingestly creates it, activates it, and selects it as this node's target right away.
A paused workflow is shown with **(Paused)** and cannot be selected. If a workflow you already selected later stops being callable, the editor says so and the workflow will not save until you fix it.
Two call nodes may target the **same** section. That is the point of a reusable section, and unlike [Forward](/nodes/forward-output) there is no rule against duplicate targets.
### Field mappings
The section's input contract decides what you map. Each contract field gets a row, and you fill it from any upstream node's output, a literal, or a template. Required contract fields must be mapped before the workflow saves.
Changing the target clears the mappings, because they are keyed to the previous target's contract.
## What the call returns
The section's [Return output](/nodes/return) decides what comes back. It arrives on this node:
| Path | Type | Description |
| ------------------ | ------ | ----------------------------------------------------------- |
| `payload.data` | object | The section's return payload, shaped by its return contract |
| `payload.subRunId` | string | The run id of the section, for linking to it |
Nodes after the call read return fields directly, for example `{{Call section.payload.data.total}}`. Because the section runs on the same document, any field coordinates it returns stay valid for highlighting.
## Waiting, failure, and retries
A call **always waits**. There is no fire-and-forget option: the whole reason to call a section is to use its result.
* If the section fails, this step fails with the section's error and a link to its run.
* If the section finishes **without reaching its Return node**, this step fails too. Nothing was produced, so there is nothing to continue with.
* If the section contains a [Review action](/nodes/review), the call waits for the reviewer. There is no timeout: the wait is durable and survives restarts. The caller's run detail shows the section as **in review** so a long wait is diagnosable without opening it.
Retries default to a single attempt, because the section's own steps already retry individually. Reserve the node's error port for routing a failed call somewhere else.
## Recursion limits
A workflow cannot call itself, and Ingestly rejects a chain that comes back around (A calls B, B calls A) when you save. A runtime depth cap of 10 backs that up.
## Inputs and outputs
**Allowed inputs:** any action node.
**Output:** the return payload above, plus an error port for routing failures.
## Credits
The call node itself is free. The section's steps bill normally, against the section's own run, so a called section costs the same as the steps would have cost inline.
## Related
Make a workflow callable and declare its input
Declare what a section hands back
The whole pattern, end to end
Hand the document off instead of calling