Streams

Streams is the identity and inspection layer that sits on top of live transport objects in Callaba Engine. It is where a concrete media flow gets a stable name, role, stream id, optional host binding, and saved codec or audio-layout context that operators can reuse later.

In practice this module becomes useful when a transport object such as an SRT server or RTMP server is not enough by itself. Once a team needs one stream to stay recognizable across monitoring, playback, and troubleshooting, this is the layer that keeps that identity intact.

Examples by preset

The easiest way to read the module is to separate a few recurring production shapes: a publisher stream on top of an SRT listener, a receiver-side stream for routed pull workflows, an RTMP-origin stream, and a stream row that stores audio context for later reuse.

{
  "name": "Main stage publisher",
  "role_name": "publisher",
  "stream_id": "publisher/main-stage/srt-main",
  "entity_id": "680400000000000000000001",
  "module_name": "MODULE_SRT_SERVERS",
  "active": true
}
{
  "name": "Remote return receiver",
  "role_name": "receiver",
  "stream_id": "receiver/main-stage/return-feed",
  "host": "198.51.100.24",
  "entity_id": "680400000000000000000001",
  "module_name": "MODULE_SRT_SERVERS",
  "active": true
}
{
  "name": "RTMP primary publish",
  "role_name": "publisher",
  "stream_id": "studio/live/program",
  "entity_id": "680500000000000000000001",
  "module_name": "MODULE_RTMP_SERVERS",
  "active": true
}

If your team triggers stream actions from an operator workflow, the create, start, and stop methods below also include vMix Script tabs alongside the usual API snippets.

Workflow examples

Keep live stream identity stable above the transport layer

Use the streams module when the transport endpoint is only one part of the story and your operators need a durable row for a specific publisher or receiver flow.

Persist audio layout or metadata after inspection

Use getStreamInfo to inspect a real upstream feed, then store the useful result in audio_settings or stream_meta_data with create, update, or setStreamInfo so the team does not have to rediscover the same details later.

Resolve a live URL for a downstream consumer

Use start and getStreamInfo when a player, operator, or downstream workflow needs a concrete SRT or RTMP address rather than only a saved transport object.

Create stream
Collapse
POST
/api/streams/create

Creates a new stream row in Callaba Engine.

The stream object does not replace an SRT server or RTMP server. It sits on top of one of those entities and keeps the stream-facing identity stable: name, role, stream id, optional host, and any saved audio metadata the team should not have to rediscover later.

If your team triggers provisioning from an operator workflow, the example set below also includes vMix Script tabs for the same create call.

Examples by preset

Start with the preset that matches the transport backing the stream. Publisher and receiver rows on top of SRT listeners behave differently in practice, and RTMP-backed rows normally carry a different stream id convention again.

Workflow-oriented use cases

Register a publisher stream above an SRT server

Use this when one managed SRT listener serves multiple named publisher flows and you want those flows to stay visible as first-class rows that operators can recognize quickly.

Persist receiver-side stream identity

Use this when routed or pulled traffic should keep a stable receiver-facing identity instead of only being implied by transport state.

Store stream-specific audio metadata

Use this when channel naming, layout, or per-track meaning should live with the stream object instead of being rediscovered every time.

SRT publisher stream

Use this when one SRT listener hosts a named publisher stream that operators should treat as a first-class object.

SRT publisher stream
curl --request POST \
--url http://localhost/api/streams/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"name": "Main stage publisher",
"role_name": "publisher",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"module_name": "MODULE_SRT_SERVERS",
"active": true
}'
SRT receiver stream

Use this when a receiver-side or returned feed should keep its own stream identity and optional host binding.

SRT receiver stream
curl --request POST \
--url http://localhost/api/streams/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"name": "Remote return receiver",
"role_name": "receiver",
"stream_id": "receiver/main-stage/return-feed",
"host": "198.51.100.24",
"entity_id": "680400000000000000000001",
"module_name": "MODULE_SRT_SERVERS",
"active": true
}'
RTMP publisher stream

Use this when the backing transport entity is an RTMP server rather than an SRT listener.

RTMP publisher stream
curl --request POST \
--url http://localhost/api/streams/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"name": "RTMP primary publish",
"role_name": "publisher",
"stream_id": "studio/live/program",
"entity_id": "680500000000000000000001",
"module_name": "MODULE_RTMP_SERVERS",
"active": true
}'
Stream with saved audio layout

Use this when channel layout and naming should be stored with the stream row after inspection.

Stream with saved audio layout
curl --request POST \
--url http://localhost/api/streams/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"name": "Commentary audio stream",
"role_name": "publisher",
"stream_id": "publisher/commentary/audio-main",
"entity_id": "680400000000000000000001",
"module_name": "MODULE_SRT_SERVERS",
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Commentary",
"channel_layout": "mono",
"channels": [
{
"id": "FC",
"name": "Commentary"
}
]
}
]
},
"active": true
}'
Request body parameters
Identity
name
string

Dashboard label: Name.

Human-facing name of the saved stream row.

role_name
string

Dashboard label: Role.

Typical product values include publisher, receiver, pusher, and puller.

stream_id
string

Stable stream identifier stored above the backing transport entity.

host
string

Optional host binding used when the stream identity should stay tied to a concrete remote peer.

Transport link
entity_id
string

Identifier of the backing transport-side entity, for example an SRT server or RTMP server.

module_name
string

Module family behind the stream row. In practice this is most often MODULE_SRT_SERVERS or MODULE_RTMP_SERVERS.

Metadata
audio_settings
object

Optional saved audio layout with named tracks and channels.

Runtime
active
boolean

Dashboard label: Enable once created.

Controls whether the stream row should be active right after provisioning.

Create stream
curl --request POST \
--url http://localhost/api/streams/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"name": "Main stage publisher",
"role_name": "publisher",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"module_name": "MODULE_SRT_SERVERS",
"active": true
}'
Response
Identity
_id / id / name / role_name / stream_id / host
mixed

Identifiers and the saved stream identity fields.

Transport link
entity_id / entityModel / module_name
mixed

Reference back to the transport object that owns or serves the stream.

Metadata
stream_meta_data / audio_settings
mixed

Saved inspection output, codec notes, and optional channel mapping metadata.

Runtime
active / created / modified
mixed

Runtime flag and backend-managed timestamps.

Operation result
success
boolean

Successful stream model responses expose success: true as a virtual field.

Response: Create stream
JSON
{
"_id": "680600000000000000000001",
"id": "680600000000000000000001",
"name": "Main stage publisher",
"role_name": "publisher",
"host": "",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"entityModel": "ServerModel",
"module_name": "MODULE_SRT_SERVERS",
"stream_meta_data": {
"codec_name": "h264",
"fps": "30/1"
},
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Track-0",
"channel_layout": "stereo",
"channels": [
{
"id": "FL",
"name": "Left"
},
{
"id": "FR",
"name": "Right"
}
]
}
]
},
"created": "2026-03-24T08:45:00.000Z",
"modified": "2026-03-24T08:45:00.000Z",
"active": true,
"success": true
}
Get streams count
Expand
POST
/api/streams/getCount

Returns the number of stream rows that match the current filter.

This is the count companion to getAll and is most useful when the team wants quick inventory numbers for stream rows without pulling the full list first.

Request body parameters
This method has no parameters
Get streams count
curl --request POST \
--url http://localhost/api/streams/getCount \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{}'
Response
count
integer

Total number of stream rows visible to the authenticated user.

Response: Get streams count
JSON
{
"count": 0
}
Get all streams
Expand
POST
/api/streams/getAll

Returns the stream rows visible to the authenticated account.

Use this when the team needs one view of the active stream identities across SRT and RTMP-backed workflows, especially when publisher and receiver roles should stay easy to scan during operations.

Request body parameters
limit
integer

Optional page size for the listing query.

skip
integer

Optional offset for paginated listing.

sort
object

Optional sort descriptor. The dashboard store defaults to { created: 1 }.

filter
object

Optional filter object used for search and role/module filtering.

Get all streams
curl --request POST \
--url http://localhost/api/streams/getAll \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"sort": {
"created": 1
},
"filter": {},
"limit": 20,
"skip": 0
}'
Response
array of stream objects
array

The backend returns a bare array of stream rows, not a wrapped object.

Response: Get all streams
JSON
[
{
"_id": "680600000000000000000001",
"id": "680600000000000000000001",
"name": "Main stage publisher",
"role_name": "publisher",
"host": "",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"entityModel": "ServerModel",
"module_name": "MODULE_SRT_SERVERS",
"stream_meta_data": {
"codec_name": "h264",
"fps": "30/1"
},
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Track-0",
"channel_layout": "stereo",
"channels": [
{
"id": "FL",
"name": "Left"
},
{
"id": "FR",
"name": "Right"
}
]
}
]
},
"created": "2026-03-24T08:45:00.000Z",
"modified": "2026-03-24T08:45:00.000Z",
"active": true,
"success": true
}
]
Get stream by id
Expand
POST
/api/streams/getById

Loads one saved stream row by id.

Use this before editing when you need the current stream identity, associated transport entity, or stored audio settings exactly as they are persisted.

Request body parameters
id
string

Identifier of the stream row you want to load.

Get stream by id
curl --request POST \
--url http://localhost/api/streams/getById \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"id": "680600000000000000000001"
}'
Response
stream object
object

The backend returns the saved stream row with its transport link and any stored metadata.

Response: Get stream by id
JSON
{
"_id": "680600000000000000000001",
"id": "680600000000000000000001",
"name": "Main stage publisher",
"role_name": "publisher",
"host": "",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"entityModel": "ServerModel",
"module_name": "MODULE_SRT_SERVERS",
"stream_meta_data": {
"codec_name": "h264",
"fps": "30/1"
},
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Track-0",
"channel_layout": "stereo",
"channels": [
{
"id": "FL",
"name": "Left"
},
{
"id": "FR",
"name": "Right"
}
]
}
]
},
"created": "2026-03-24T08:45:00.000Z",
"modified": "2026-03-24T08:45:00.000Z",
"active": true,
"success": true
}
Update stream
Expand
POST
/api/streams/update

Updates a saved stream row.

In practice this is where teams rename a stream, adjust its role-facing metadata, attach or revise saved audio settings, or correct the stream id and host pairing after live inspection.

Request body parameters
id
string

Identifier of the stream row to update.

name / role_name / stream_id / host
mixed

Updated stream identity fields.

audio_settings
object

Optional replacement audio layout or saved channel naming data.

active
boolean

Current runtime-enabled flag after the update.

Update stream
curl --request POST \
--url http://localhost/api/streams/update \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"id": "680600000000000000000001",
"name": "Main stage publisher",
"role_name": "publisher",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"module_name": "MODULE_SRT_SERVERS",
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Program",
"channel_layout": "stereo",
"channels": [
{
"id": "FL",
"name": "Left"
},
{
"id": "FR",
"name": "Right"
}
]
}
]
},
"active": true
}'
Response
updated stream object
object

The backend returns the updated stream row.

Response: Update stream
JSON
{
"_id": "680600000000000000000001",
"id": "680600000000000000000001",
"name": "Main stage publisher",
"role_name": "publisher",
"host": "",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"entityModel": "ServerModel",
"module_name": "MODULE_SRT_SERVERS",
"stream_meta_data": {
"codec_name": "h264",
"fps": "30/1"
},
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Track-0",
"channel_layout": "stereo",
"channels": [
{
"id": "FL",
"name": "Left"
},
{
"id": "FR",
"name": "Right"
}
]
}
]
},
"created": "2026-03-24T08:45:00.000Z",
"modified": "2026-03-24T08:45:00.000Z",
"active": true,
"success": true
}
Set stream info
Expand
POST
/api/streams/setStreamInfo

Stores stream information for a concrete live flow identified by stream_id, role, and port context.

Use it when the team already knows which live flow is the right one and wants its discovered details saved without manually re-entering everything through a broader edit flow.

Request body parameters
short_stream_id
string

Short stream identifier, usually the tail of the full stream id.

stream_id
string

Full stream identifier in the product-specific role path format.

role
string

Runtime role for this stream info write, for example publisher or receiver.

port / receiver_port
mixed

Transport context used to resolve where the stream info belongs.

Set stream info
curl --request POST \
--url http://localhost/api/streams/setStreamInfo \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"short_stream_id": "srt-main",
"stream_id": "publisher/main-stage/srt-main",
"role": "publisher",
"port": 1935,
"receiver_port": 1936
}'
Response
success
boolean

The backend confirms that the stream info write finished successfully.

Response: Set stream info
JSON
{
"success": true
}
Remove stream
Expand
DELETE
/api/streams/remove

Removes a saved stream row.

Use this when the stream identity should disappear from the operator layer and no longer be shown as an active managed stream object.

Query parameters
id
string

Identifier of the stream row to delete.

Remove stream
curl --request DELETE \
--url http://localhost/api/streams/remove \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"id": "680600000000000000000001"
}'
Response
success
boolean

The backend confirms that the stream row was removed.

Response: Remove stream
JSON
{
"success": true
}
Start stream
Expand
POST
/api/streams/start

Starts the underlying stream runtime for the selected stream row.

This is the operational companion to stream provisioning. It matters when a saved stream identity should immediately become an active runtime flow that another team, player, or downstream step can rely on.

If this action is triggered from an operator workflow, the example set below includes a vMix Script tab as well.

Request body parameters
id
string

Identifier of the stream row to start.

Start stream
curl --request POST \
--url http://localhost/api/streams/start \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"id": "680600000000000000000001"
}'
Response
started stream object
object

The backend returns the stream row after the start action is accepted.

Response: Start stream
JSON
{
"_id": "680600000000000000000001",
"id": "680600000000000000000001",
"name": "Main stage publisher",
"role_name": "publisher",
"host": "",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"entityModel": "ServerModel",
"module_name": "MODULE_SRT_SERVERS",
"stream_meta_data": {
"codec_name": "h264",
"fps": "30/1"
},
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Track-0",
"channel_layout": "stereo",
"channels": [
{
"id": "FL",
"name": "Left"
},
{
"id": "FR",
"name": "Right"
}
]
}
]
},
"created": "2026-03-24T08:45:00.000Z",
"modified": "2026-03-24T08:45:00.000Z",
"active": true,
"success": true
}
Stop stream
Expand
POST
/api/streams/stop

Stops the runtime for the selected stream row.

Use this to take the stream offline without deleting the saved metadata and identity around it.

If this action is triggered from an operator workflow, the example set below includes a vMix Script tab as well.

Request body parameters
id
string

Identifier of the stream row to stop.

Stop stream
curl --request POST \
--url http://localhost/api/streams/stop \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"id": "680600000000000000000001"
}'
Response
stopped stream object
object

The backend returns the stream row after the stop action is accepted.

Response: Stop stream
JSON
{
"_id": "680600000000000000000001",
"id": "680600000000000000000001",
"name": "Main stage publisher",
"role_name": "publisher",
"host": "",
"stream_id": "publisher/main-stage/srt-main",
"entity_id": "680400000000000000000001",
"entityModel": "ServerModel",
"module_name": "MODULE_SRT_SERVERS",
"stream_meta_data": {
"codec_name": "h264",
"fps": "30/1"
},
"audio_settings": {
"streams": [
{
"id": 0,
"name": "Track-0",
"channel_layout": "stereo",
"channels": [
{
"id": "FL",
"name": "Left"
},
{
"id": "FR",
"name": "Right"
}
]
}
]
},
"created": "2026-03-24T08:45:00.000Z",
"modified": "2026-03-24T08:45:00.000Z",
"active": true,
"success": true
}
Get stream info
Expand
POST
/api/streams/getStreamInfo

Runs a stream inspection against a live URL and returns codec, audio, and timing details for the real upstream feed.

Use it when the team needs facts from the live signal before deciding what should be saved into the stream row or passed on to another workflow.

Request body parameters
stream_url
string

Live input URL that should be inspected with FFprobe.

Get stream info
curl --request POST \
--url http://localhost/api/streams/getStreamInfo \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"stream_url": "srt://127.0.0.1:1936?streamid=publisher/main-stage/srt-main"
}'
Response
streams[]
array

FFprobe-style stream descriptors for video, audio, or data tracks discovered on the live input.

streams[].codec_name / codec_type
mixed

Codec identity for each discovered track.

streams[].width / height / avg_frame_rate
mixed

Representative video properties when the input includes a video track.

streams[].sample_rate / channels / channel_layout
mixed

Representative audio properties when the input includes audio tracks.

format
object

Top-level FFprobe format object for the inspected URL.

Response: Get stream info
JSON
{
"streams": [
{
"index": 0,
"codec_name": "h264",
"codec_type": "video",
"width": 1920,
"height": 1080,
"avg_frame_rate": "30/1",
"pix_fmt": "yuv420p"
},
{
"index": 1,
"codec_name": "aac",
"codec_type": "audio",
"sample_rate": "48000",
"channels": 2,
"channel_layout": "stereo"
}
],
"format": {
"filename": "srt://127.0.0.1:1936",
"nb_streams": 2,
"format_name": "mpegts",
"start_time": "0.000000",
"probe_score": 100
}
}