---
id: plugins-guides-flow-to-flow
title: "Flow to flow"
summary: "Ways for one flow to use another - start it, call it over a pipe and get an answer, publish it as a plugin, or connect over HTTP and event streams."
audience: user
keywords: "flow to flow, call flow, sub-flow, Start flow, Pipe client, Pipe listener, flow plugin, Plugin port, reuse"
---
# Flow to flow

Split a large integration into flows that each do one job, and let them use each other. Pick the way by what the
calling flow needs back.

| You need | Use |
|---|---|
| To start another flow, without passing data | **Start flow** |
| To send records to a running flow, and get an answer back | **Pipe client** → **Pipe listener** |
| To reuse a flow as a component in many flows | [Publish the flow as a plugin](/documentation/publishing/) |
| To reach a flow on another machine, or from another system | **Http client** → **Http listener**, webhooks, or Kafka, MQTT or NATS |

## Start another flow

**Start flow** starts the flow you pick, as if you pressed Start. Its `Continue` pin fires as soon as the flow has
started or, with **WaitForFinish**, when it has stopped. Use it to chain jobs that run once:

```text
Timer → Start flow (import, WaitForFinish) → Start flow (report)
```

The started flow gets no data from the caller. A flow that keeps running, because it has a Timer or a listener, never
finishes.

## Call a running flow

A **Pipe listener** is the entry point of a flow that serves other flows; a **Pipe client** calls it. With a two-way
listener the client waits for the answer and sends it on.

```text
Customer service:  Pipe listener (GetCustomer) → Table reader → Data mapper → Pipe listener Response
Caller:            Http listener → Pipe client (Customer service/GetCustomer) → Http response
```

When you pick the listener in the client, the client takes over its request and response types. The called flow is
started if it is not running. Errors in the called flow come back as errors of the Pipe client, so a **Try catch** in
the caller handles them. Pipes run between flows on the same machine.

## Reuse a flow as a component

Publish a flow as a plugin and it appears in the toolbox like any other plugin. A **Plugin port** receives the record
and a **Plugin port response** sends the result back. See [Publish a flow as a plugin](/documentation/publishing/).

## Across machines

Between machines, or to and from other systems, use the transport that fits: **Http client** and **Http listener** for
request and answer, **Webhook sender** and **Webhook receiver** for notifications, and the [event
plugins](/documentation/plugins/event/) for streams.

**Sync call** does not call other flows: it orders steps inside one flow. See
[Pins and routing](./pins-and-routing#one-pin-several-connections).