Create an SRT Flow

POST

flows

Create Flow

curl --request POST \
  --url https://client.camb.ai/apis/flows \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "label": "stadium-encoder",
  "mode": "listener",
  "failover": true
}
'

import requests

url = "https://client.camb.ai/apis/flows"

payload = {
    "label": "stadium-encoder",
    "mode": "listener",
    "failover": True
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({label: 'stadium-encoder', mode: 'listener', failover: true})
};

fetch('https://client.camb.ai/apis/flows', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://client.camb.ai/apis/flows",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'label' => 'stadium-encoder',
    'mode' => 'listener',
    'failover' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

{
  "id": 123,
  "label": "<string>",
  "failover": true,
  "active": true,
  "team_id": 123,
  "key": "<string>",
  "play_url": "<string>",
  "push_urls": [
    {
      "url": "<string>"
    }
  ],
  "passphrase": "<string>"
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>"
    }
  ]
}

Overview

A flow is a standing SRT endpoint hosted by Camb.ai, independent of any stream. Create one once, and use its URLs as the source or a target of any number of streams, with no need to expose your own SRT infrastructure. Flows come in two modes:

Listener

Camb.ai hosts an SRT endpoint your encoder pushes to. You get one or two push_urls (primary/backup) and a play_url anyone with the key can pull from.

Caller

Camb.ai pulls from your SRT endpoint (primary_url) and re-serves it on a stable play_url, with optional failover to a backup_url.

Using a flow with streams

The returned play_url is a normal SRT URL:

As a stream source - set it as source_stream.url when creating a stream. Your encoder pushes to the flow’s push_urls; the stream ingests from the flow.
As a stream target - set it as a target_streams[].url with "type": 1 to deliver your processed output to the flow, then distribute the flow’s play_url to viewers or downstream systems.

Set a passphrase (10–79 characters) to encrypt the flow’s endpoint. It is embedded in the returned URLs and required to connect. To pull from an upstream that is itself encrypted (caller mode), append its passphrase to primary_url as a query parameter: srt://host:port?passphrase=....

Example: listener flow for a stadium encoder

curl -X POST "https://client.camb.ai/apis/flows" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "label": "stadium-encoder",
    "mode": "listener",
    "failover": true
  }'

import requests

payload = {
    "label": "stadium-encoder",
    "mode": "listener",
    "failover": True,
}

response = requests.post(
    "https://client.camb.ai/apis/flows",
    headers={"x-api-key": "YOUR_API_KEY"},
    json=payload,
)

response.raise_for_status()
flow = response.json()
print(flow["push_urls"])  # give these to your encoder
print(flow["play_url"])   # use this as source_stream.url

The response contains everything needed to use the flow:

{
  "id": 42,
  "label": "stadium-encoder",
  "mode": "listener",
  "failover": true,
  "active": true,
  "team_id": 7,
  "key": "k3yk3yk3yk3yk3yk3yk3yk3yk",
  "play_url": "srt://live.camb.ai:20121?streamid=play/42/k3yk3yk3yk3yk3yk3yk3yk3yk",
  "push_urls": [
    {
      "role": "primary",
      "url": "srt://live.camb.ai:20121?streamid=publish/42-primary/k3yk3yk3yk3yk3yk3yk3yk3yk"
    },
    {
      "role": "backup",
      "url": "srt://live.camb.ai:20121?streamid=publish/42-backup/k3yk3yk3yk3yk3yk3yk3yk3yk"
    }
  ],
  "passphrase": null
}

Validation rules

label must be unique within your team.
caller mode requires primary_url; listener mode must not set URLs.
backup_url requires failover: true (and is required for caller flows with failover).

Errors

403 - Your subscription does not include streaming.
422 - Validation error (see the rules above).

Authorizations

x-api-key

string

header

required

The x-api-key is a custom header required for authenticating requests to our API. Include this header in your request with the appropriate API key value to securely access our endpoints. You can find your API key(s) in the 'API' section of our studio website.

Body

application/json

Configuration for a new stream flow - a standing SRT endpoint you can use as the source or a target of any stream.

label

string

required

Human-readable name for the flow. Must be unique within your team.

mode

enum<string>

required

caller: Camb.ai connects out to your SRT endpoint (primary_url) and re-serves it. listener: Camb.ai hosts an SRT endpoint that your encoder pushes to.

Available options:

caller,

listener

failover

boolean

default:false

Enable a second (backup) leg. Caller flows then require backup_url; listener flows get a backup push URL.

primary_url

string | null

SRT URL of your upstream (caller mode only; required there, forbidden for listeners). To dial an encrypted upstream, append its passphrase as a query parameter: srt://host:port?passphrase=....

backup_url

string | null

SRT URL of the backup upstream. Caller mode with failover enabled only.

passphrase

string | null

Optional SRT encryption passphrase for the flow's own endpoint (10-79 characters). When set, it is embedded in the returned play/push URLs and required to connect.

Required string length: 10 - 79

Response

The created flow, including its play and push URLs.

integer

Flow identifier.

label

string

mode

enum<string>

caller: Camb.ai connects out to your SRT endpoint (primary_url) and re-serves it. listener: Camb.ai hosts an SRT endpoint that your encoder pushes to.

Available options:

caller,

listener

failover

boolean

active

boolean

Whether the flow's relay is currently online.

team_id

integer

key

string

Access key embedded in the flow's URLs.

play_url

string

SRT URL the flow serves. Use it as source_stream.url or as a target_streams[].url, or play it directly.

push_urls

PushUrl · object[]

SRT URLs to push into (listener mode). Empty for caller flows.

Hide child attributes

push_urls.role

enum<string>

Which leg of the flow this URL feeds.

Available options:

primary,

backup

push_urls.url

string

SRT URL to push to.

passphrase

string | null

The flow's SRT encryption passphrase, when one is set.

Last modified on July 24, 2026

List SRT FlowsList all stream flows belonging to your team.

Create Flow

curl --request POST \
  --url https://client.camb.ai/apis/flows \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "label": "stadium-encoder",
  "mode": "listener",
  "failover": true
}
'

import requests

url = "https://client.camb.ai/apis/flows"

payload = {
    "label": "stadium-encoder",
    "mode": "listener",
    "failover": True
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({label: 'stadium-encoder', mode: 'listener', failover: true})
};

fetch('https://client.camb.ai/apis/flows', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://client.camb.ai/apis/flows",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'label' => 'stadium-encoder',
    'mode' => 'listener',
    'failover' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

{
  "id": 123,
  "label": "<string>",
  "failover": true,
  "active": true,
  "team_id": 123,
  "key": "<string>",
  "play_url": "<string>",
  "push_urls": [
    {
      "url": "<string>"
    }
  ],
  "passphrase": "<string>"
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>"
    }
  ]
}

Getting Started

Models

Tutorials

SDK Guides

Hosting Platforms

Integrations

API Reference

Other Products

Release Logs

Create an SRT Flow

Overview

Listener

Caller

Using a flow with streams

Example: listener flow for a stadium encoder

Validation rules

Errors

Authorizations

Body

Response

​Overview

Listener

Caller

​Using a flow with streams

​Example: listener flow for a stadium encoder

​Validation rules

​Errors

​Related endpoints

Authorizations

Body

Response

Overview

Using a flow with streams

Example: listener flow for a stadium encoder

Validation rules

Errors

Related endpoints