Command-first documentation

Search the module, then move faster through the API

Find the exact module, copy the working request shape, and move from product workflow to API call without getting buried in the tree.

AI workflow helperDescribe what you want to buildOptional tool

Write the workflow in plain language. We will turn it into a GPT-ready brief you can use to generate requests, module order, and starter payloads.

SRT routes

On this page

Find an endpoint

8 endpoints

Search current page endpoints by name, HTTP verb, or URL

Search by endpoint name, HTTP verb, or URL, then jump straight to its request.

SRT routes RTMP servers NDI discovered devices

The SRT routes section describes the endpoints used to create and manage route objects that take an incoming source and send it to an outgoing SRT destination in Callaba Engine.

In practice, this is the API layer you use when you want a persistent source-to-destination routing object that can be started, stopped, queried, and updated over time.

The route model is easiest to read in four practical layers: what the route is called, where it receives the signal, where it should hand that signal off next, and whether that handoff should already be live when the route is created.

Route presets and request mapping

SRT routes are not one flat request shape. The payload changes depending on the source choice, destination choice, and whether the route needs the extra SRT controls that only matter once reliability or latency becomes a real production concern.

Basic settings: route name and whether the route should be enabled immediately.
Source presets: the API supports at least an SRT listen-port source, an SRT Stream URL (srt://) source, and a UDP source for route input.
Destination presets: the API supports an SRT listen-port destination and an SRT Output URL (srt://) destination for route output.
Advanced settings: the visible fields depend on the selected source and destination type. SRT destination mode exposes the richest advanced block.

How the create payload is shaped

The create payload has three layers: the route itself, the source side, and the destination side. The exact request shape depends on the kind of handoff you want to support in production.

For example, a route built from URL-based source and destination uses input_stream_url and output_stream_url. A listen-based route instead uses the listen-port objects plus the advanced SRT settings that help when stability and latency need closer control.

Examples by preset

These examples are organized around real routing decisions, so teams can copy the shape that matches the way they want traffic to move instead of reverse-engineering one oversized generic payload.

Listen SRT port to SRT Output URL

Use this pattern when Callaba should listen for an incoming SRT contribution on a local port and then forward it to an outgoing SRT destination.

{
  "router_name": "Route from listen port to SRT output",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://127.0.0.1:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}

SRT Stream URL to listen SRT port

Use this pattern when the route should pull from an upstream SRT URL and expose the outgoing side as a local listener destination.

{
  "router_name": "Route from SRT URL to listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": false
}

Workflow examples

These scenarios connect SRT routes to the rest of the product model. They are useful when you are designing a pipeline, not just calling /api/srt-routes/create in isolation.

Use a route as a stable upstream for Restream

Create an SRT route first when you want the ingest side and the outbound SRT handoff to stay stable while the downstream restream job changes independently. This is a good fit when your input source is fixed, but your social destinations or transcoding settings change often.

Module path: MODULE_SRT_ROUTERS -> MODULE_RESTREAM
Why it helps: the route becomes the stable transport boundary, and the restream job can be recreated or restarted without changing the ingest side.
Typical shape: listen or pull with SRT route, then use the route output URL as the input to the restream module.

Use a route as a clean handoff into recording

Use an SRT route when you want to normalize or isolate the source before it reaches the recording module. This is especially helpful when the route should stay persistent, but recordings are created only for selected events or schedules.

Module path: MODULE_SRT_ROUTERS -> MODULE_RECORDINGS
Why it helps: recording jobs can target the route output instead of binding directly to the original source every time.
Typical shape: route the incoming contribution into a listen port or SRT URL, then point the recording workflow at that route output.

Use a route to separate source ownership from downstream consumers

Routes are useful when one team owns ingest and another team owns downstream consumers. Instead of exposing the original source directly to every module, you expose a route output and treat it as the shared handoff point.

Good fit for: shared infrastructure, QA environments, scheduled recordings, or multiple downstream consumers.
Operational benefit: the route can be started, stopped, or updated independently from the downstream jobs that read from it.
Documentation implication: if you are building a pipeline in stages, document the route output first and then attach Restream, Recording, or another route consumer afterward.

POST

/api/srt-routes/create

Creates a new SRT route resource in Callaba Engine.

The current Swagger definition exposes this method as POST /api/srt-routes/create with an application/json request body that contains the route name, source configuration, destination configuration, and active flag.

The exact nested fields depend on how the route should receive the signal and how it should hand that signal off. The descriptions below are written so a team can choose the route shape that best matches the production path they actually want to run.

In live product tests, the create response returns the created route on the top level together with success: true, but the route's input and output arrays are still empty immediately after creation. Use getById if you need the expanded source and destination objects.

Authentication uses the dashboard-issued JWT token in the x-access-token header.

vMix note: use Create SRT route from vMix only when the production needs to provision a route on demand. For most live buttons and shortcuts, teams create the route ahead of time and then trigger Start or Stop instead.

Workflow-oriented use cases

These examples are useful when you are designing a real pipeline and need to decide why the route exists, not only what the payload looks like.

Put a stable route in front of Restream

Use this pattern when the ingest side should stay fixed, but the downstream restream job may be recreated, restarted, or pointed at different social destinations over time. The route output becomes the stable upstream that the restream module reads from.

Module chain: MODULE_SRT_ROUTERS -> MODULE_RESTREAM
Why teams use it: it separates source ownership from social distribution logic.
What to keep stable: route output URL or route listen port.

Put a stable route in front of Recording

Use this pattern when you want scheduled or event-specific recordings to attach to a stable route output instead of binding directly to the original contribution source every time.

Module chain: MODULE_SRT_ROUTERS -> MODULE_RECORDINGS
Why teams use it: the route can stay persistent while recording jobs come and go.
Typical fit: recurring ingest, selective recording windows, or QA-friendly archive pipelines.

Preset-driven request shapes

If you are trying to mirror familiar routing scenarios in your own integration, use the scenario-specific request examples below. Each preset has its own request block with language tabs and copy support.

SRT listen port

The route listens on a local SRT port and owns the incoming contribution handoff.

SRT listen port to SRT listen port

Destination preset: SRT listen port. The route exposes a local SRT listening port for downstream consumers that connect later.

SRT listen port to SRT listen port

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT listen port to SRT Output URL

Destination preset: SRT Output URL. The route pushes to a downstream SRT destination URL right away.

SRT listen port to SRT Output URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT listen port to UDP Output URL

Destination preset: UDP Output URL. The route hands off to a downstream UDP destination URL when the next hop expects UDP.

SRT listen port to UDP Output URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to UDP Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_UDP_URL",
    "output_stream_url": "udp://destination.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT Stream URL

The route pulls from an upstream SRT URL instead of waiting on a local listening port.

SRT Stream URL to SRT listen port

Destination preset: SRT listen port. The route exposes a local SRT listening port for downstream consumers that connect later.

SRT Stream URL to SRT listen port

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT Stream URL to SRT Output URL

Destination preset: SRT Output URL. The route pushes to a downstream SRT destination URL right away.

SRT Stream URL to SRT Output URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT Stream URL to UDP Output URL

Destination preset: UDP Output URL. The route hands off to a downstream UDP destination URL when the next hop expects UDP.

SRT Stream URL to UDP Output URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to UDP Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_UDP_URL",
    "output_stream_url": "udp://destination.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

UDP Stream URL

The route reads from a UDP source URL when the upstream side is already exposed as UDP.

UDP Stream URL to SRT listen port

Destination preset: SRT listen port. The route exposes a local SRT listening port for downstream consumers that connect later.

UDP Stream URL to SRT listen port

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from UDP Stream URL to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_UDP_URL",
    "input_stream_url": "udp://upstream.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

UDP Stream URL to SRT Output URL

Destination preset: SRT Output URL. The route pushes to a downstream SRT destination URL right away.

UDP Stream URL to SRT Output URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from UDP Stream URL to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_UDP_URL",
    "input_stream_url": "udp://upstream.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

UDP Stream URL to UDP Output URL

Destination preset: UDP Output URL. The route hands off to a downstream UDP destination URL when the next hop expects UDP.

UDP Stream URL to UDP Output URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from UDP Stream URL to UDP Output URL",
  "input": {
    "input_type": "INPUT_TYPE_UDP_URL",
    "input_stream_url": "udp://upstream.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_UDP_URL",
    "output_stream_url": "udp://destination.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

Request body parameters

Basic settings

router_name

string

Dashboard label: Route name.

Characters: A-Z, a-z, 0-9, and -.

Source

input.input_type

string

Dashboard group: SRT/UDP route source.

The route source type. In the dashboard, the SRT option is shown as SRT Stream URL (srt://). The current example uses INPUT_TYPE_SRT_URL.

input.input_stream_url

string

Dashboard label: SRT Stream URL (srt://).

Connect to the specified URL address and try to pull the stream. The current example uses a listener URL: srt://0.0.0.0:2034?mode=listener.

Advanced source settings

input.input_settings.rcvbuf

integer

Dashboard label: Receiver buffer size.

This is an optional advanced SRT input setting. The dashboard tooltip says the default receiver buffer size is 12058624 bytes and the recommended value is 48234496 bytes. Live route tests confirm the API accepts this field and returns it from getById when it is set.

Source

input.module_name

string

Input module name. For SRT routes the dashboard and Swagger example use MODULE_SRT_ROUTERS.

Destination

output.output_type

string

Dashboard group: SRT route destination.

Dashboard label: Stream destination.

In the dashboard, the SRT destination option is shown as SRT Output URL (srt://). The current example uses OUTPUT_TYPE_SRT_URL.

output.output_stream_url

string

Dashboard label: Output Stream URL.

Specify the address of the streaming platform or the stream destination. The current example uses srt://0.0.0.0:2035.

output.module_name

string

Output module name. For SRT routes the dashboard and Swagger example use MODULE_SRT_ROUTERS.

Source

input.input_stream_listen_port.port

integer

Listen source preset: SRT Port.

When the route source is built from the dashboard's listen-port preset, the default port is 2035. This is the practical alternative to input.input_stream_url.

Advanced source settings

input.input_settings.host

string

Dashboard label: SRT Listen Host.

The local IP address to bind. The dashboard tooltip explicitly calls out 0.0.0.0 for all interfaces and 127.0.0.1 for localhost-only binding. The default is 0.0.0.0.

input.input_settings.latency

integer

Dashboard label: Latency.

Defines the maximum accepted transmission latency. The current dashboard default for route SRT settings is 500 ms.

input.input_settings.rcvlatency

integer

Dashboard label: Receiver latency.

Minimum receiver buffering delay before the application gets the packet. The current dashboard default is 200 ms.

input.input_settings.fc

integer

Dashboard label: Flow control window size.

Limits the maximum number of packets in flight. The current dashboard default is 25600 pkts.

input.input_settings.inputbw

integer

Dashboard label: Input bandwidth.

Set this to the anticipated bitrate of the live stream. The current dashboard default is 750000 Byte/s.

input.input_settings.oheadbw

integer

Dashboard label: Recovery bandwidth.

Bandwidth overhead above the input bandwidth, in percent. The current dashboard default is 25%.

input.input_settings.maxbw

integer

Dashboard label: Bandwidth limit.

The listen-source constants still define this field with a default of 0, even though the route Swagger example does not show it.

input.input_settings.streamid

string

Dashboard label: Stream ID (optional).

Available on the SRT listen/source configuration block.

input.input_settings.passphrase

string

Dashboard label: Passphrase (optional).

Password for the encrypted transmission. The dashboard tooltip says it must be between 10 and 79 characters.

Destination

output.output_stream_listen_port.port

integer

Listen destination preset: SRT Port.

When the route destination is built from the dashboard's listen-port preset, the default port is 3035. This is the practical alternative to output.output_stream_url.

Advanced destination settings

output.output_settings.host

string

Dashboard label: SRT Host.

In listener mode this is the local IP to bind, and in caller or rendezvous mode it is the remote IP to connect to. The current dashboard default is 0.0.0.0.

output.output_settings.mode

string

Dashboard label: Mode.

Possible values are caller, listener, or rendezvous. The current dashboard default is the second SRT mode option, which corresponds to the default route form shown in the UI.

output.output_settings.latency

integer

Dashboard label: Latency.

Defines the maximum accepted transmission latency. The current dashboard default is 500 ms.

output.output_settings.rcvlatency

integer

Dashboard label: Receiver latency.

Minimum receiver buffering delay before data is delivered to the receiving application. The current dashboard default is 200 ms.

output.output_settings.fc

integer

Dashboard label: Flow control window size.

The current dashboard default is 25600 pkts.

output.output_settings.sndbuf

integer

Dashboard label: Sender Buffer Size.

The current dashboard default is 12288000 Bytes.

output.output_settings.rcvbuf

integer

Dashboard label: Receiver Buffer Size.

The current dashboard default is 12288000 Bytes.

output.output_settings.inputbw

integer

Dashboard label: Input bandwidth.

The current dashboard default is 750000 Byte/s.

output.output_settings.oheadbw

integer

Dashboard label: Recovery bandwidth.

The current dashboard default is 25%.

output.output_settings.streamid

string

Dashboard label: Stream ID (optional).

The dashboard tooltip notes that it is settable in Caller mode only.

output.output_settings.passphrase

string

Dashboard label: Passphrase (optional).

Password for encrypted transmission. The dashboard tooltip says it must be between 10 and 79 characters.

output.output_settings.enforcedencryption

string

Dashboard label: Enforced encryption.

Requires both connection parties to either use the same passphrase or both omit the passphrase. Otherwise the connection is rejected.

output.output_settings.groupconnect

string

Dashboard label: Accept group connections.

When enabled on a listener socket, it allows this socket to accept group connections.

output.output_settings.groupminstabletimeo

integer

Dashboard label: Group stability timeout.

The current dashboard default is 60 ms.

output.output_settings.conntimeo

integer

Dashboard label: Connection timeout.

Applies to caller and rendezvous connection modes. The current dashboard default is 3000 ms.

Route state

active

boolean

Dashboard label: Enable once created.

Controls whether the route should be enabled immediately after creation.

Response

_id

string

Identifier of the newly created SRT route.

string

Convenience alias for the created route identifier. In live responses, id matches _id.

router_name

string

Name stored for the created route.

input

array

Immediately after creation, the live product returns an empty input array on the top level. Use getById to fetch expanded input objects.

output

array

Immediately after creation, the live product returns an empty output array on the top level. Use getById to fetch expanded output objects.

active

boolean

Whether the route is enabled after creation.

created

string

Creation timestamp returned by the live product.

success

boolean

The live product returns a boolean success flag together with the created route object. On success it is true.

Response: Create SRT route

JSON

POST

/api/srt-routes/getAll

Returns a list of SRT routes visible to the authenticated user.

The current Swagger definition exposes this method as POST /api/srt-routes/getAll with a small pagination body. In live product tests, the response is a bare array of route objects rather than a wrapped response envelope.

Each item includes the route name, active state, and expanded input and output objects, so this method is a good fit for dashboards, listings, and route status views.

Request body parameters

Pagination

limit

integer

Maximum number of routes to return in one response page.

skip

integer

Offset used for pagination. Use 0 for the first page.

sort.created

integer

Sort direction for the route creation timestamp. The Swagger example uses 1 for ascending order.

Get all SRT routes

Response

Response list

[]

array

The live product returns a bare array of SRT route objects rather than a wrapped envelope.

router_name

string

Name of each SRT route in the returned array.

Source

input[]

array

Expanded input objects attached to the route, including the input type, input stream URL, and optional input_settings such as rcvbuf when configured.

Destination

output[]

array

Expanded output objects attached to the route, including the output type and output stream URL.

active

boolean

Whether the route is currently active.

success

boolean

Each returned item currently includes success: true in the live response.

Response: Get all SRT routes

JSON

[
  {
    "_id": "69c1de8e28c95839e0dffb74",
    "router_name": "Awesome SRT route updated",
    "input": [
      {
        "_id": "69c1de8e28c95839e0dffb91",
        "input_type": "INPUT_TYPE_SRT_URL",
        "input_stream_url": "srt://0.0.0.0:2034?mode=listener",
        "module_name": "MODULE_SRT_ROUTERS",
        "__v": 0
      }
    ],
    "output": [
      {
        "_id": "69c1de8e28c95839e0dffb94",
        "output_type": "OUTPUT_TYPE_SRT_URL",
        "output_stream_url": "srt://0.0.0.0:2035",
        "module_name": "MODULE_SRT_ROUTERS",
        "__v": 0
      }
    ],
    "active": false,
    "user_id": "69360341db559495f643de6a",
    "created": "2026-03-24T00:45:02.729Z",
    "__v": 0,
    "modified": "2026-03-24T00:45:02.886Z",
    "id": "69c1de8e28c95839e0dffb74",
    "success": true
  }
]

POST

/api/srt-routes/getById

Loads one SRT route by id.

The current Swagger definition exposes this method as POST /api/srt-routes/getById with a simple body containing the route id.

In live product tests, this method returns the full route object on the top level together with expanded input and output arrays. That makes it the best method to call when you need the current persisted route configuration before rendering an edit form or a detailed route view.

Request body parameters

string

Identifier of the SRT route you want to load.

Get SRT route by id

Response

_id

string

Identifier of the requested route.

router_name

string

Name of the requested route.

input[]

array

Expanded input objects for the route source. When advanced SRT input settings are used, the live product also returns them under input_settings.

output[]

array

Expanded output objects for the route destination.

active

boolean

Whether the route is currently enabled.

success

boolean

The live product returns the requested route object together with success: true.

Response: Get SRT route by id

JSON

{
  "_id": "69c1de8e28c95839e0dffb74",
  "router_name": "Awesome SRT route updated",
  "input": [
    {
      "_id": "69c1de8e28c95839e0dffb91",
      "input_type": "INPUT_TYPE_SRT_URL",
      "input_stream_url": "srt://0.0.0.0:2034?mode=listener",
      "module_name": "MODULE_SRT_ROUTERS",
      "__v": 0
    }
  ],
  "output": [
    {
      "_id": "69c1de8e28c95839e0dffb94",
      "output_type": "OUTPUT_TYPE_SRT_URL",
      "output_stream_url": "srt://0.0.0.0:2035",
      "module_name": "MODULE_SRT_ROUTERS",
      "__v": 0
    }
  ],
  "active": false,
  "user_id": "69360341db559495f643de6a",
  "created": "2026-03-24T00:45:02.729Z",
  "__v": 0,
  "modified": "2026-03-24T00:45:02.886Z",
  "id": "69c1de8e28c95839e0dffb74",
  "success": true
}

POST

/api/srt-routes/update

Updates an existing SRT route by id.

The current Swagger definition exposes this method as POST /api/srt-routes/update with the route id plus the updated route body.

In live product tests, the response returns the updated route object on the top level together with success: true, but, just like create, the top-level input and output arrays come back empty immediately after update. If you need the expanded linked objects, call getById after the update succeeds.

Request body parameters

string

Identifier of the route you want to update.

router_name

string

Updated route name.

input

object

Updated source configuration object for the route.

output

object

Updated destination configuration object for the route.

active

boolean

Updated enabled state for the route.

Update SRT route

curl --request POST \
  --url http://localhost/api/srt-routes/update \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "id": "SRT_ROUTE_ID",
  "router_name": "Awesome SRT route updated",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

Response

router_name

string

Updated route name returned by the live product.

modified

string

Modification timestamp set by the product.

input

array

Immediately after update, the live product currently returns empty top-level input and output arrays.

success

boolean

The live product returns the updated route object together with success: true.

Response: Update SRT route

JSON

POST

/api/srt-routes/start

Starts an SRT route by id.

The current Swagger definition exposes this method as POST /api/srt-routes/start with the route id in the request body.

In live product tests, the response returns the updated route on the top level together with success: true. After the route starts, the input and output fields are returned as linked object ids rather than expanded objects, and the route becomes active: true.

vMix note: this is a good fit for a button, shortcut, or trigger when the route already exists and operators only need to bring the path online at the right moment.

Request body parameters

string

Identifier of the route you want to start.

Start SRT route

Response

input

array

After start, the live product returns input as an array of linked input object ids.

output

array

After start, the live product returns output as an array of linked output object ids.

active

boolean

Becomes true when the route is started successfully.

success

boolean

The live product returns the updated route object together with success: true.

Response: Start SRT route

JSON

POST

/api/srt-routes/stop

Stops an SRT route by id.

The current Swagger definition exposes this method as POST /api/srt-routes/stop with the route id in the request body.

In live product tests, the response returns the updated route on the top level together with success: true. The route becomes active: false, and the linked input and output values are still returned as ids rather than expanded objects.

vMix note: this pairs naturally with Start SRT route in operator-facing controls when you want a clean way to take the route offline without deleting it.

Request body parameters

string

Identifier of the route you want to stop.

Stop SRT route

Response

input

array

After stop, the live product still returns linked input object ids rather than expanded objects.

output

array

After stop, the live product still returns linked output object ids rather than expanded objects.

active

boolean

Becomes false when the route is stopped successfully.

success

boolean

The live product returns the updated route object together with success: true.

Response: Stop SRT route

JSON

POST

/api/srt-routes/getCount

DELETE

/api/srt-routes/remove

Back toRTMP servers Next toNDI discovered devices