Build reusable, composable n8n sub-workflows. Use when extracting shared logic, building anything multi-step or reused across workflows, or any workflow over ~10 nodes — and whenever the user mentions sub-workflows, Execute Workflow, reuse, shared/common logic, modular workflows, "Define Below" inpu

n8n Sub workflows A sub workflow is a reusable function. An Execute Workflow Trigger declares typed inputs, the body does the work, and the last node returns the output. A caller invokes it through an Execute Workflow node like any other step. That framing buys you the things functions buy you everywhere: encapsulation, reuse, testability, replaceability. It's the primary reuse mechanism in n8n, and it's badly underused. Without it, the same logic gets copy pasted across workflows — then a bug gets fixed in two places, the third copy gets missed, and your "identical" copies quietly drift apart. This skill is about when to reach for a sub workflow, how to define its input/output contract so callers (and agents) can actually use it, how to call it correctly ( all vs each , blocking vs fire and forget), and how to name it so it gets found instead of rebuilt. The two non negotiables Everything else is judgement. These two are not. 1. Search before you build Before you write logic for a generic problem, check whether a sub workflow already does it. The community MCP can't filter workflows by tag, so the name is the discovery surface : If something fits, use it and tell the user ("I found Subworkflow: Parse RFC2822 date — using that"). If nothing fits, build it with a discoverable name so the next search finds it. The discovery convention (verb first prefixes) lives in NAMING AND DISCOVERY.md . 2. The Execute Workflow Trigger uses "Define Below" with typed fields — not passthrough The trigger has two input modes. Default to "Define Below" with explicit typed fields. Define Below is the only mode that gives callers a schema to fill — it's what lets an AI agent pass values via $fromAI and what lets structured callers map fields cleanly. Passthrough has no schema, so the trigger can't be wired as a clean agent tool and structured callers have nothing to bind to. Two exceptions, and only two: Binary input. Typed fields are JSON only. If the sub workflow must receive an image/file/PDF, you need passthrough so the binary slot flows through. Zero inputs. Define Below requires at least one field. A genuinely no arg operation ("list active credentials", "current count") has nowhere to put an empty schema, so passthrough is the only option. Outside those two cases, passthrough is a bug. See "Inputs and outputs as a contract" below. Should this be a sub workflow? You're about to write a chunk of logic. Run it through this: The reasons to extract go beyond reuse: Readability. The caller shows one node ("Parse date") instead of five. Testability. Run the sub workflow alone with pinned input: n8n test workflow({workflowId, method: "prepare"}) names the nodes that need data, then method: "pinned" runs it with what you build (needs N8N MCP ACCESS TOKEN and the workflow's "Available in MCP" setting — see n8n mcp tools expert ). A sub workflow has no HTTP trigger, so the default method: "auto" cannot run it. Replaceability. Swap the implementation without rippling to callers. A 20 node workflow is fine if it's mostly a linear sequence of Execute Workflow calls and decisions — each node has one purpose, and you inspect a section by opening the sub workflow it calls. A 20 node workflow of inline transformations is not fine. If yours has 15+ nodes and isn't mostly sub workflow calls and branches, extract more. Stateless vs. stateful (deliberately) Both are first class. The choice is about intent and what the contract promises. Stateless — input in, output out, no I/O beyond that. The default for pure logic. When you need it again, you call it without worrying about side effects firing. Subworkflow: Parse RFC2822 date — date string → ISO date or error. Subworkflow: Compute MRR from subscription — subscription object → number. Subworkflow: Format invoice as HTML — invoice data → HTML string. Stateful (deliberate) — reads or writes external state behind a clean contract . This is the repository pattern: the sub workflow abstracts the storage operation so callers think in domain terms, not SQL. Customer: get by id — id → customer object or { ok: false, error: "not found" } . Reads the DB. Customer: write billing record — record → { ok: true, id } . Writes the DB. Notify: send to on call — channel, message → { ok: true, messageId } . Calls Slack/SMTP. Why build these as sub workflows: callers think get customer by id instead of writing the query; you can swap the store (Postgres → Supabase, native node → HTTP) without touching a single caller; and idempotency, retry, and validation get centralized in one place. What to avoid is accidental state — a sub workflow named and described as pure that quietly writes to a log table. That ambushes every caller who reasonably assumed it was safe to retry or compose. Either make the side effect part of the contract (rename it, document it, return its result) or move it out. Inputs and outputs as a contract The trigger's declared fields and the last node's output shape are the sub workflow's API. Treat them like one. Declaring typed inputs (Define Below) Each declared input is a typed parameter the caller fills. Pick types deliberately ( string , number , boolean , array , object ) — an agent uses these as the required types when filling tool parameters, and humans rely on them when wiring callers. The trigger node parameters look like this: Inside the body, read them as $json.list of ids , or from anywhere downstream as $('When Executed by Another Workflow').first().json.<field (see n8n expression syntax ). The contract rules Document inputs and outputs in the workflow description . Field names, types, purpose, and a few representative keywords. The description is what callers (human and agent) read for the contract, and it's what n8n list workflows matches against. Return consistent, natural shapes — not storage shapes. A sub workflow that owns a Data Table or an S3 file hides that representation from callers. Arrays return as arrays, objects as objects, dates as ISO strings — regardless of whether the underlying storage was JSON stringified text. The return contract is the interface ; the storage layout is implementation detail . Common slip: a sub workflow with a "fresh" path (just computed, natural shape) and a "cached" path (just read from a stringified column). Wrong instinct: stringify the fresh path to match the cached one. Right instinct: parse the cached path so both return the natural shape. Return errors, don't always throw. For expected failures (a parse error, a not found), return { ok: false, error: "..." } so the caller can branch without wiring an error output. Reserve throwing for genuinely unexpected failures — see n8n error handling . The contract is frozen once it has callers. Adding optional fields is safe. Renaming or removing a field is dangerous: n8n won't error on an unrecognized input field — the body just sees undefined , the caller has no idea, and you get a silent contract break. To change a field, enumerate every caller ( n8n list workflows + inspect each one's Execute Workflow node), migrate them in the same change, and verify with validate workflow and n8n get workflow before you're done. The final Return node — the legitimate Set exception Shape the output with a final Set / Edit Fields node, named Return or Return <thing . This is the one place a Set node earns its keep against the usual "don't add a trailing Set node" advice from n8n expression syntax : the implicit consumer of a sub workflow's last node is every caller , so an explicit Set makes the return contract visible — a reader sees the whole API by reading one node, and you strip any noise fields the last computation node carried. Calling sub workflows: mode and waitForSubWorkflow Two settings on the caller's Execute Workflow node decide how the sub workflow runs. mode : all vs each mode Sub workflow runs Items per run all (default) once all N items (flowing per item through nodes as usual) each N times exactly one item per run For a body that just processes items the normal way, the two are equivalent — n8n nodes iterate per item either way. The split only matters when the body assumes it sees exactly one item : a per run aggregation, "this is THE customer to act on" logic, or a final write that should fire once per input. With all , that body gets all N items at once and the assumption breaks (you aggregate everyone into one result instead of one per input). With each , each invocation gets one item and the assumption holds. So: when you need per item iteration, prefer mode: each over dropping a Loop Over Items node inside the sub workflow. The mode does the iteration for you, and the body stays simple and single item. waitForSubWorkflow : true vs false waitForSubWorkflow defaults to true — the caller blocks until the sub workflow returns, then continues with its output. Set options.waitForSubWorkflow: false to fire and forget: the call dispatches, the caller moves on immediately, the sub workflow runs in the background, and downstream sees no return data. The only true parallelization n8n offers mode: each + waitForSubWorkflow: false is the only way to get genuinely concurrent sub workflow execution : N items dispatch N runs that execute in parallel (still bounded by per instance concurrency limits). The caller doesn't know when — or whether — any of them finished, so it's only useful with a separate completion tracking mechanism, typically a Data Table the sub workflow updates as it progresses. The full stage → dispatch → poll pattern is in SUBWORKFLOW PATTERNS.md ("Fire and forget parallelization"). Splitting by input shape (the N+1 pattern) When a sub workflow has multiple input paths whose contracts genuinely differ — binary vs JSON, sync vs async, divergent auth schemes — don't cram them under one trigger with passthrough + an internal Switch. The forcing function is real: passthrough (for binary or zero input) and Define Below (for typed inputs) are mutually exclusive on a single trigger. The reflex to "pick passthrough because it's most permissive, then branch inside" costs you the typed schema (no clean agent tool), grows branch shape cruft, and turns every new input shape into more branching. The fix: for N divergent input contracts, build N+1 sub workflows — one outer per contract, each doing its input specific prep (validation, fetching, hashing, extraction) and calling one shared downstream sub workflow with a normalized shape. The shared core has a single typed input contract and knows nothing about which outer called it. The worked example (process a paper from an external ID or an uploaded PDF) is in SUBWORKFLOW PATTERNS.md . Sub workflow as an agent tool A sub workflow with a typed Define Below trigger doubles as an AI agent tool: the agent fills the declared fields via $fromAI , the body runs, the result comes back as the tool observation. This is the high value reason to default to Define Below — passthrough triggers can't expose a fill able schema. The zero input case still works as a tool: the agent's only decision is whether to invoke. The binary case does not wire cleanly as a tool, because agents can't pass binary directly. For tool naming, descriptions, and the binary input workaround, see n8n agents ; for the binary handling itself, n8n binary and data . Anti patterns Anti pattern What goes wrong Fix Duplicating the same logic in three workflows A bug gets fixed in two places, the third drifts Extract once to a named sub workflow Building a new sub workflow without searching The library grows duplicates; future searches find both n8n list workflows / n8n get workflow first Trig

n8n-subworkflows