Flow
Trigger a flow in response to a state change in one or more other flows.

Trigger a flow in response to a state change in one or more other flows.

You can trigger a flow as soon as another flow ends. This allows you to add implicit dependencies between multiple flows, which can often be managed by different teams.

A flow trigger must have preconditions which filter on other flow executions. It can also have standard trigger conditions. Neither condition type can use Pebble templating expressions; they must be declaratively defined. Upstream execution outputs will be available in a trigger.outputs variable.

yaml
type: "io.kestra.plugin.core.trigger.Flow"

Examples

Trigger the transform flow after the extract flow finishes successfully. The extract flow generates a date output that is passed to the transform flow as an input.

yaml

id: extract
namespace: company.team

tasks: 
  - id: final_date
    type: io.kestra.plugin.core.debug.Return
    format: "{{ execution.startDate | dateAdd(-2, 'DAYS') | date('yyyy-MM-dd') }}"

outputs: 
  - id: date
    type: STRING
    value: "{{ outputs.final_date.value }}"

The transform flow is triggered after the extract flow finishes successfully.

yaml
id: transform
namespace: company.team

inputs:
  - id: date
    type: STRING
    defaults: "2025-01-01"

variables:
  result: |
    Ingestion done in {{ trigger.executionId }}.
    Now transforming data up to {{ inputs.date }}

tasks:
  - id: run_transform
    type: io.kestra.plugin.core.debug.Return
    format: "{{ render(vars.result) }}"

  - id: log
    type: io.kestra.plugin.core.log.Log
    message: "{{ render(vars.result) }}"

triggers:
  - id: run_after_extract
    type: io.kestra.plugin.core.trigger.Flow
    inputs:
      date: "{{ trigger.outputs.date }}"
    preconditions:
      id: flows
      flows:
        - namespace: company.team
          flowId: extract
          states: [SUCCESS]

Trigger the silver_layer flow once the bronze_layer flow finishes successfully by 9 AM.

yaml

id: bronze_layer
namespace: company.team

tasks: 
  - id: raw_data
    type: io.kestra.plugin.core.log.Log
    message: Ingesting raw data

yaml
id: silver_layer
namespace: company.team

tasks:
  - id: transform_data
    type: io.kestra.plugin.core.log.Log
    message: deduplication, cleaning, and minor aggregations

triggers:
  - id: flow_trigger
    type: io.kestra.plugin.core.trigger.Flow
    preconditions:
      id: bronze_layer
      timeWindow:
        type: DAILY_TIME_DEADLINE
        deadline: "09:00:00"
      flows:
        - namespace: company.team
          flowId: bronze_layer
          states: [SUCCESS]

Create a System Flow to send a Slack alert on any failure or warning state within the company namespace. This example uses the Slack webhook secret to notify the #general channel about the failed flow.

yaml
id: alert
namespace: system

tasks:
  - id: send_alert
    type: io.kestra.plugin.notifications.slack.SlackExecution
    url: "{{secret('SLACK_WEBHOOK')}}" # format: https://hooks.slack.com/services/xzy/xyz/xyz
    channel: "#general"
    executionId: "{{trigger.executionId}}"

triggers:
  - id: alert_on_failure
    type: io.kestra.plugin.core.trigger.Flow
    states:
      - FAILED
      - WARNING
    preconditions:
      id: company_namespace
      where:
        - id: company
          filters:
            - field: NAMESPACE
              type: STARTS_WITH
              value: company

Create a System Flow to send a Sentry issue on any failure or warning state within the company.payroll namespace. This example uses the Sentry Execution task and a Flow trigger with conditions.

yaml
id: sentry_execution_example
namespace: company.team

tasks:
- id: send_alert
  type: io.kestra.plugin.notifications.sentry.SentryExecution
  executionId: "{{ trigger.executionId }}"
  transaction: "/execution/id/{{ trigger.executionId }}"
  dsn: "{{ secret('SENTRY_DSN') }}"
  level: ERROR

triggers:
- id: failed_prod_workflows
  type: io.kestra.plugin.core.trigger.Flow
  conditions:
  - type: io.kestra.plugin.core.condition.ExecutionStatus
    in:
      - FAILED
      - WARNING
  - type: io.kestra.plugin.core.condition.ExecutionNamespace
    namespace: company.payroll
    prefix: false

Chain two different flows (flow_a and flow_b) and trigger the second only after the first completes successfully with matching labels. Note that this example is two separate flows.

yaml
id: flow_a
namespace: company.team
labels:
  type: orchestration
tasks:
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: Hello World!
---
id: flow_b
namespace: company.team

tasks:
  - id: hello
    type: io.kestra.plugin.core.log.Log
    message: Hello World!

triggers:
  - id: on_completion
    type: io.kestra.plugin.core.trigger.Flow
    states: [SUCCESS]
    labels:
      type: orchestration
    preconditions:
      id: flow_a
        id: flow_a
        where:
          - id: label_filter
            filters:
              - field: EXPRESSION
                type: IS_TRUE
                value: "{{ labels.type == 'orchestration' }}

Properties

allowConcurrentboolean

Defaultfalse

Specifies whether a trigger is allowed to start a new execution even if a previous run is still in progress.

conditions

List of conditions in order to limit the flow trigger.

Definitions

Condition to allow events between two specific datetime values.

type*object

afterstring

Formatdate-time

The date to test must be after this one.

beforestring

Formatdate-time

The date to test must be before this one.

Must be a valid ISO 8601 datetime with the zone identifier (use 'Z' for the default zone identifier).

datestring

Default{{ trigger.date }}

Condition to allow events on a particular day of the week.

dayOfWeek*string

Possible Values

MONDAYTUESDAYWEDNESDAYTHURSDAYFRIDAYSATURDAYSUNDAY

type*object

datestring

Default{{ trigger.date }}

Condition to execute tasks on a specific day of the week relative to the current month (first, last, ...)

dayInMonth*string

Possible Values

FIRSTLASTSECONDTHIRDFOURTH

Are you looking for the first or the last day in the month?

dayOfWeek*string

Possible Values

MONDAYTUESDAYWEDNESDAYTHURSDAYFRIDAYSATURDAYSUNDAY

The day of week.

type*object

datestring

Default{{ trigger.date }}

Condition for a specific flow of an execution.

flowId*string

namespace*string

type*object

Condition that checks labels of an execution.

labels*arrayobject

List of labels to match in the execution.

type*object

Condition for an execution namespace.

namespace*string

String against which to match the execution namespace depending on the provided comparison.

type*object

comparisonstring

Possible Values

EQUALSPREFIXSUFFIX

Comparison to use when checking if namespace matches. If not provided, it will use EQUALS by default.

prefixbooleanstring

Defaultfalse

Whether to look at the flow namespace by prefix. Shortcut for comparison: PREFIX.

Only used when comparison is not set

Condition based on the outputs of an upstream execution.

expression*booleanstring

type*object

Condition based on execution status.

type*object

inarray

SubTypestring

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

notInarray

SubTypestring

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

Condition based on variable expression.

expression*string

type*object

Condition for a specific flow. Note that this condition is deprecated, use `io.kestra.plugin.core.condition.ExecutionFlow` instead.

flowId*string

The flow id.

namespace*string

The namespace of the flow.

type*object

Condition for a flow namespace.

namespace*string

The namespace of the flow or the prefix if prefix is true.

type*object

prefixboolean

Defaultfalse

If we must look at the flow namespace by prefix (checked using startsWith). The prefix is case sensitive.

Condition that matches if any taskRun has retry attempts.

type*object

inarray

SubTypestring

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of states that are authorized.

notInarray

SubTypestring

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of states that aren't authorized.

Run a flow if the list of preconditions is met in a time window.

conditions*object

The list of preconditions to wait for

The key must be unique for a trigger because it will be used to store the previous evaluation result.

id*string

Validation RegExp^[a-zA-Z0-9][a-zA-Z0-9_-]*

Min length1

A unique id for the condition

type*object

resetOnSuccessboolean

Defaulttrue

Whether to reset the evaluation results of SLA conditions after a first successful evaluation within the given time period.

By default, after a successful evaluation of the set of SLA conditions, the evaluation result is reset, so, the same set of conditions needs to be successfully evaluated again in the same time period to trigger a new execution. This means that to create multiple executions, the same set of conditions needs to be evaluated to true multiple times. You can disable this by setting this property to false so that, within the same period, each time one of the conditions is satisfied again after a successful evaluation, it will trigger a new execution.

timeWindow

Default

{
  "type": "DURATION_WINDOW"
}

Define the time period (or window) for evaluating preconditions.

You can set the type of sla to one of the following values:

DURATION_WINDOW: this is the default type. It uses a start time (windowAdvance) and end time (window) that are moving forward to the next interval whenever the evaluation time reaches the end time, based on the defined duration window. For example, with a 1-day window (the default option: window: PT1D), the SLA conditions are always evaluated during 24h starting at midnight (i.e. at time 00: 00: 00) each day. If you set windowAdvance: PT6H, the window will start at 6 AM each day. If you set windowAdvance: PT6H and you also override the window property to PT6H, the window will start at 6 AM and last for 6 hours — as a result, Kestra will check the SLA conditions during the following time periods: 06: 00 to 12: 00, 12: 00 to 18: 00, 18: 00 to 00: 00, and 00: 00 to 06: 00, and so on.
SLIDING_WINDOW: this option also evaluates SLA conditions over a fixed time window, but it always goes backward from the current time. For example, a sliding window of 1 hour (window: PT1H) will evaluate executions for the past hour (so between now and one hour before now). It uses a default window of 1 day.
DAILY_TIME_DEADLINE: this option declares that some SLA conditions should be met "before a specific time in a day". With the string property deadline, you can configure a daily cutoff for checking conditions. For example, deadline: "09: 00: 00" means that the defined SLA conditions should be met from midnight until 9 AM each day; otherwise, the flow will not be triggered.
DAILY_TIME_WINDOW: this option declares that some SLA conditions should be met "within a given time range in a day". For example, a window from startTime: "06: 00: 00" to endTime: "09: 00: 00" evaluates executions within that interval each day. This option is particularly useful for declarative definition of freshness conditions when building data pipelines. For example, if you only need one successful execution within a given time range to guarantee that some data has been successfully refreshed in order for you to proceed with the next steps of your pipeline, this option can be more useful than a strict DAG-based approach. Usually, each failure in your flow would block the entire pipeline, whereas with this option, you can proceed with the next steps of the pipeline as soon as the data is successfully refreshed at least once within the given time range.

io.kestra.core.models.triggers.TimeWindow

deadlinestring

Formatpartial-time

endTimestring

Formatpartial-time

startTimestring

Formatpartial-time

typestring

DefaultDURATION_WINDOW

Possible Values

DAILY_TIME_DEADLINEDAILY_TIME_WINDOWDURATION_WINDOWSLIDING_WINDOW

windowstring

Formatduration

windowAdvancestring

Formatduration

windowstring

Formatduration

Deprecated, use timeWindow.window instead.

windowAdvancestring

Formatduration

Deprecated, use timeWindow.windowAdvance instead.

Condition to exclude other conditions.

conditions*

Min items1

The list of conditions to exclude.

If any condition is true, it will prevent the event's execution.

type*object

Condition to have at least one condition validated.

conditions*

Min items1

The list of conditions to validate.

If any condition is true, it will allow the event's execution.

type*object

Condition to allow events on public holidays.

type*object

countrystring

ISO 3166-1 alpha-2 country code. If not set, it uses the country code from the default locale.

datestring

Default{{ trigger.date}}

subDivisionstring

ISO 3166-2 country subdivision (e.g., provinces and states) code.

It uses the Jollyday library for public holiday calendar that supports more than 70 countries.

Condition to allow events between two specific times.

type*object

afterstring

Formattime

The time to test must be after this one.

beforestring

Formattime

The time to test must be before this one.

Must be a valid ISO 8601 time with offset.

datestring

Default{{ trigger.date }}

The time to test.

Can be any variable or any valid ISO 8601 time. By default, it will use the trigger date.

Condition to allow events on weekend.

type*object

datestring

Default{{ trigger.date }}

The date to test.

Can be any variable or any valid ISO 8601 datetime. By default, it will use the trigger date.

inputsobject

Pass upstream flow's outputs to inputs of the current flow.

The inputs property passes data objects or a file to the downstream flow as long as those outputs are defined on the flow-level in the upstream flow.

Make sure that the inputs and task outputs defined in this Flow trigger match the outputs of the upstream flow. Otherwise, the downstream flow execution will not to be created. If that happens, go to the Logs tab on the Flow page to investigate the error.

preconditions

Preconditions on upstream flow executions

Express preconditions to be met, on a time window, for the flow trigger to be evaluated.

Definitions

io.kestra.plugin.core.trigger.Flow-Preconditions

id*string

Validation RegExp^[a-zA-Z0-9][a-zA-Z0-9_-]*

Min length1

A unique id for the preconditions

flowsarray

A list of preconditions to meet, in the form of upstream flows

io.kestra.plugin.core.trigger.Flow-UpstreamFlow

namespace*string

The namespace of the flow

flowIdstring

The flow ID

labelsobject

A key/value map of labels

statesarray

SubTypestring

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

The execution states

resetOnSuccessboolean

Defaulttrue

Whether to reset the evaluation results of preconditions after a first successful evaluation within the given time window

By default, after a successful evaluation of the set of preconditions, the evaluation result is reset. This means the same set of conditions needs to be successfully evaluated again within the same time window to trigger a new execution. In this setup, to create multiple executions, the same set of conditions must be evaluated to true multiple times within the defined window. You can disable this by setting this property to false, so that within the same window, each time one of the conditions is satisfied again after a successful evaluation, it will trigger a new execution.

timeWindow

Default

{
  "type": "DURATION_WINDOW"
}

Define the time window for evaluating preconditions.

You can set the type of timeWindow to one of the following values:

DURATION_WINDOW: this is the default type. It uses a start time (windowAdvance) and end time (window) that advance to the next interval whenever the evaluation time reaches the end time, based on the defined duration window. For example, with a 1-day window (the default option: window: PT1D), the preconditions are evaluated during a 24-hour period starting at midnight (i.e., at "00: 00: 00+00: 00") each day. If you set windowAdvance: PT6H, the window will start at 6 AM each day. If you set windowAdvance: PT6H and also override the window property to PT6H, the window will start at 6 AM and last for 6 hours. In this configuration, the preconditions will be evaluated during the following intervals: 06: 00 to 12: 00, 12: 00 to 18: 00, 18: 00 to 00: 00, and 00: 00 to 06: 00.
SLIDING_WINDOW: this option evaluates preconditions over a fixed time window but always goes backward from the current time. For example, a sliding window of 1 hour (window: PT1H) evaluates executions within the past hour (from one hour ago up to now). It uses a default window of 1 day.
DAILY_TIME_DEADLINE: this option declares that preconditions should be met "before a specific time in a day." Using the string property deadline, you can configure a daily cutoff for evaluating preconditions. For example, deadline: "09: 00: 00" specifies that preconditions must be met from midnight until 9 AM UTC time each day; otherwise, the flow will not be triggered.
DAILY_TIME_WINDOW: this option declares that preconditions should be met "within a specific time range in a day". For example, a window from startTime: "06: 00: 00" to endTime: "09: 00: 00" evaluates executions within that interval each day. This option is particularly useful for defining freshness conditions declaratively when building data pipelines that span multiple teams and namespaces. Normally, a failure in any task in your flow will block the entire pipeline, but with this decoupled flow trigger alternative, you can proceed as soon as the data is successfully refreshed within the specified time window.

io.kestra.core.models.triggers.TimeWindow

deadlinestring

Formatpartial-time

SLA daily deadline

Use it only for DAILY_TIME_DEADLINE SLA.

endTimestring

Formatpartial-time

SLA daily end time

startTimestring

Formatpartial-time

SLA daily start time

Use it only for DAILY_TIME_WINDOW SLA.

typestring

DefaultDURATION_WINDOW

Possible Values

DAILY_TIME_DEADLINEDAILY_TIME_WINDOWDURATION_WINDOWSLIDING_WINDOW

The type of the SLA

The default SLA is a sliding window (DURATION_WINDOW) with a window of 24 hours.

windowstring

Formatduration

The duration of the window

Use it only for DURATION_WINDOW or SLIDING_WINDOW SLA. See ISO_8601 Durations for more information of available duration value. The start of the window is always based on midnight except if you set windowAdvance parameter. Eg if you have a 10 minutes (PT10M) window, the first window will be 00: 00 to 00: 10 and a new window will be started each 10 minutes

windowAdvancestring

Formatduration

The window advance duration

Use it only for DURATION_WINDOW SLA. Allow to specify the start time of the window Eg: you want a window of 6 hours (window=PT6H), by default the check will be done between: 00: 00 and 06: 00, 06: 00 and 12: 00, 12: 00 and 18: 00, and 18: 00 and 00: 00. If you want to check the window between 03: 00 and 09: 00, 09: 00 and 15: 00, 15: 00 and 21: 00, and 21: 00 and 3: 00, you will have to shift the window of 3 hours by settings windowAdvance: PT3H

wherearray

A list of preconditions to meet, in the form of execution filters

io.kestra.plugin.core.trigger.Flow-ExecutionFilter

filters*array

Min items1

The list of filters

io.kestra.plugin.core.trigger.Flow-Filter

field*string

Possible Values

FLOW_IDNAMESPACESTATEEXPRESSION

The field which will be filtered

type*string

Possible Values

EQUAL_TONOT_EQUAL_TOINNOT_INIS_TRUEIS_FALSEIS_NULLIS_NOT_NULLSTARTS_WITHENDS_WITHREGEXCONTAINS

The type of filter

Can be set to one of the following: EQUAL_TO, NOT_EQUAL_TO, IS_NULL, IS_NOT_NULL, IS_TRUE, IS_FALSE, STARTS_WITH, ENDS_WITH, REGEX, CONTAINS. Depending on the type, you will need to also set the value or values property.

valuestring

The single value to filter the field on

Must be set according to its type.

valuesarray

SubTypestring

The list of values to filter the field on

Must be set for the following types: IN, NOT_IN.

id*string

Min length1

A unique identifier for the filter

operandstring

DefaultAND

Possible Values

ANDOR

The operand to apply between all filters of the precondition

statesarray

SubTypestring

Default

[
  "SUCCESS",
  "WARNING",
  "FAILED",
  "KILLED",
  "CANCELLED",
  "RETRIED",
  "SKIPPED",
  "RESUBMITTED",
  "PAUSED"
]

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of execution states that will be evaluated by the trigger

By default, only executions in a terminal state or in the PAUSED state will be evaluated. Any ExecutionStatus-type condition will be evaluated after the list of states. Note that a Flow trigger cannot react to the CREATED state because the Flow trigger reacts to state transitions. The CREATED state is the initial state of an execution and does not represent a state transition.

The trigger will be evaluated for each state change of matching executions. If a flow has two Pause tasks, the execution will transition from PAUSED to a RUNNING state twice — one for each Pause task. In this case, a Flow trigger listening to a PAUSED state will be evaluated twice.

stopAfterarray

SubTypestring

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

List of execution states after which a trigger should be stopped (a.k.a. disabled).

Outputs

executionId*string

The execution ID that triggered the current flow

executionLabels*object

The execution labels that triggered the current flow

flowId*string

The flow ID whose execution triggered the current flow

flowRevision*integer

The flow revision that triggered the current flow

namespace*string

The namespace of the flow that triggered the current flow

state*string

Possible Values

CREATEDSUBMITTEDRUNNINGPAUSEDRESTARTEDKILLINGSUCCESSWARNINGFAILEDKILLEDCANCELLEDQUEUEDRETRYINGRETRIEDSKIPPEDBREAKPOINTRESUBMITTED

The execution state

outputsobject

The extracted outputs from the flow that triggered the current flow

Azure

Leverage Microsoft Azure services within Kestra data workflows.

CloudMessagingStorageBatchTool

Python

Tasks that run Python scripts with optional dependencies.

Script

Bun

Tasks that run Bun scripts.

Script

Flow
Trigger a flow in response to a state change in one or more other flows.

Create automations with Core Trigger Flow

Automatically Create a GitHub Issue When a Workflow or Job Fails

Create HubSpot Tickets Automatically for Incident Management

Create Jira Issues Automatically for Incident Management

More Plugins in this Category

Azure

Python

Bun

1.2.1

FlowTrigger a flow in response to a state change in one or more other flows.

Create automations with Core Trigger Flow

Automatically Create a GitHub Issue When a Workflow or Job Fails

Create HubSpot Tickets Automatically for Incident Management

Create Jira Issues Automatically for Incident Management

More Plugins in this Category

Azure

Python

Bun

1.2.1

Flow
Trigger a flow in response to a state change in one or more other flows.