Cascading Parameters

What you'll learn

In this tutorial, you'll learn how to:

  • Reference a node from one Pipe inside another Pipe
  • Pass query parameters through the Pipe dependency chain

Prerequisites

Overview

In Tinybird, a Pipe can have multiple nodes. Each node contains a SQL SELECT statement that reads from a Data Source or from a previous node in the same Pipe.

You can also read from a node in a different Pipe. This lets you reuse query logic across multiple Endpoints without duplicating SQL.

When you reference another Pipe, its query parameters cascade: if both Pipes define a parameter with the same name, the value you pass to the Endpoint is forwarded to the dependency too.

1

Set up the project

Create a new directory and scaffold a Tinybird project:

mkdir cascading-params && cd cascading-params

tb create
2

Create the helper Pipe

Create a Pipe that generates an hourly time series between a start and end timestamp. This Pipe is not an Endpoint — it's a helper that other Pipes can reference.

pipes/hourly_time_range.pipe
DESCRIPTION >
    Generate hourly timestamps between start and end.

NODE time_window
SQL >
    %
    SELECT
        _end,
        {% if defined(start) %}
            toStartOfInterval(toDateTime({{DateTime(start)}}), INTERVAL 1 HOUR) AS _start
        {% else %}
            _end - INTERVAL 24 HOUR AS _start
        {% end %}
    FROM
    (
        SELECT
            {% if defined(end) %}
                toStartOfInterval(toDateTime({{DateTime(end)}}), INTERVAL 1 HOUR) AS _end
            {% else %}
                toStartOfInterval(now(), INTERVAL 1 HOUR) AS _end
            {% end %}
    )

NODE time_series
SQL >
    SELECT
        _start + (number * 3600) AS time
    FROM time_window
    ARRAY JOIN range(dateDiff('hour', _start, _end)) AS number

This Pipe has two nodes:

  • time_window: calculates the start and end of the range using the start and end query parameters.
  • time_series: expands the range into one row per hour using ARRAY JOIN.
3

Create the Endpoint that references the helper

Create a second Pipe that reads from hourly_time_range and publishes the result as an Endpoint.

endpoints/time_series_endpoint.pipe
DESCRIPTION >
    Return an hourly time series by referencing the helper pipe.

NODE time_series
SQL >
    %
    SELECT time
    FROM hourly_time_range

TYPE ENDPOINT

The FROM hourly_time_range clause references the helper Pipe by its name. Tinybird resolves this to the last node of hourly_time_range.pipe (the time_series node).

When you reference another Pipe by name, Tinybird reads from its last node. You don't need to specify the node name.

4

Validate and build locally

Start Tinybird Local and build the project:

tb local start

tb build

If the build succeeds, both Pipes are deployed locally and the dependency between them is resolved.

5

Test the Endpoint

Copy the local admin token and call the Endpoint, passing the start parameter:

tb token copy "admin local_testing@tinybird.co" && TB_LOCAL_TOKEN=$(pbpaste)

curl -s "http://localhost:7181/v0/pipes/time_series_endpoint.json?start=2026-02-17%2000:00:00&token=$TB_LOCAL_TOKEN"

Even though you're calling the time_series_endpoint Endpoint, the start parameter cascades to hourly_time_range because both Pipes use a parameter named start. The response contains hourly timestamps starting from the value you passed:

{
    "data":
    [
        {"time": "2026-02-17 00:00:00"},
        {"time": "2026-02-17 01:00:00"},
        {"time": "2026-02-17 02:00:00"}
    ]
}

You can also pass the end parameter to control the upper bound:

curl -s "http://localhost:7181/v0/pipes/time_series_endpoint.json?start=2026-02-17%2000:00:00&end=2026-02-17%2006:00:00&token=$TB_LOCAL_TOKEN"

How cascading works

Parameters with the same name in different Pipes are cascaded down the dependency chain. When you call an Endpoint with start=2026-02-17, the value is forwarded to every Pipe in the chain that defines a start parameter.

This means you can build reusable query logic in helper Pipes and expose it through multiple Endpoints, all sharing the same parameters.

Common errors

If a Pipe references a node from another Pipe that doesn't exist or isn't deployed, you'll see an error like:

Node 'my_node' from pipe 'my_pipe' depends on 'other_pipe', but it is missing or not accessible in the deployment

To fix this, make sure the referenced Pipe is included in your project and is deployed. Run tb build locally to validate all dependencies before deploying.

Next steps

Updated