Create a Stream

POST

stream

Create Stream

curl --request POST \
  --url https://client.camb.ai/apis/stream \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "name": "Saturday Match Live Dub",
  "description": "Football match commentary dubbed from English into Spanish",
  "end_time": "2026-08-01T21:45:00Z",
  "timezone": "UTC",
  "voices": [],
  "source_stream": {
    "id": "match-feed",
    "url": "srt://ingest.example.com:9000",
    "latency": 2000,
    "category": 2
  },
  "audio_selections": [
    {
      "id": "commentary",
      "source": "$first_audio",
      "source_language": 1
    }
  ],
  "processing_profiles": [
    {
      "id": "dubbing",
      "demixing": "best_model",
      "transcribing": "best_model",
      "translating": "best_model",
      "revoicing": "best_model"
    }
  ],
  "pipelines": [
    {
      "id": "spanish",
      "profile": "dubbing",
      "audio_selection": "commentary",
      "outputs": [
        {
          "id": "es-audio",
          "kind": "audio",
          "language": 54
        },
        {
          "id": "es-subtitle",
          "kind": "subtitle",
          "language": 54
        }
      ]
    }
  ],
  "target_streams": [
    {
      "id": "spanish-out",
      "url": "srt://delivery.example.com:9100",
      "type": 1,
      "inputs": [
        {
          "asset_id": "es-audio"
        },
        {
          "passthrough_selector": "v:0"
        }
      ]
    }
  ]
}
'

import requests

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

payload = {
    "name": "Saturday Match Live Dub",
    "description": "Football match commentary dubbed from English into Spanish",
    "end_time": "2026-08-01T21:45:00Z",
    "timezone": "UTC",
    "voices": [],
    "source_stream": {
        "id": "match-feed",
        "url": "srt://ingest.example.com:9000",
        "latency": 2000,
        "category": 2
    },
    "audio_selections": [
        {
            "id": "commentary",
            "source": "$first_audio",
            "source_language": 1
        }
    ],
    "processing_profiles": [
        {
            "id": "dubbing",
            "demixing": "best_model",
            "transcribing": "best_model",
            "translating": "best_model",
            "revoicing": "best_model"
        }
    ],
    "pipelines": [
        {
            "id": "spanish",
            "profile": "dubbing",
            "audio_selection": "commentary",
            "outputs": [
                {
                    "id": "es-audio",
                    "kind": "audio",
                    "language": 54
                },
                {
                    "id": "es-subtitle",
                    "kind": "subtitle",
                    "language": 54
                }
            ]
        }
    ],
    "target_streams": [
        {
            "id": "spanish-out",
            "url": "srt://delivery.example.com:9100",
            "type": 1,
            "inputs": [{ "asset_id": "es-audio" }, { "passthrough_selector": "v:0" }]
        }
    ]
}
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({
    name: 'Saturday Match Live Dub',
    description: 'Football match commentary dubbed from English into Spanish',
    end_time: '2026-08-01T21:45:00Z',
    timezone: 'UTC',
    voices: [],
    source_stream: {
      id: 'match-feed',
      url: 'srt://ingest.example.com:9000',
      latency: 2000,
      category: 2
    },
    audio_selections: [{id: 'commentary', source: '$first_audio', source_language: 1}],
    processing_profiles: [
      {
        id: 'dubbing',
        demixing: 'best_model',
        transcribing: 'best_model',
        translating: 'best_model',
        revoicing: 'best_model'
      }
    ],
    pipelines: [
      {
        id: 'spanish',
        profile: 'dubbing',
        audio_selection: 'commentary',
        outputs: [
          {id: 'es-audio', kind: 'audio', language: 54},
          {id: 'es-subtitle', kind: 'subtitle', language: 54}
        ]
      }
    ],
    target_streams: [
      {
        id: 'spanish-out',
        url: 'srt://delivery.example.com:9100',
        type: 1,
        inputs: [{asset_id: 'es-audio'}, {passthrough_selector: 'v:0'}]
      }
    ]
  })
};

fetch('https://client.camb.ai/apis/stream', 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/stream",
  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([
    'name' => 'Saturday Match Live Dub',
    'description' => 'Football match commentary dubbed from English into Spanish',
    'end_time' => '2026-08-01T21:45:00Z',
    'timezone' => 'UTC',
    'voices' => [
        
    ],
    'source_stream' => [
        'id' => 'match-feed',
        'url' => 'srt://ingest.example.com:9000',
        'latency' => 2000,
        'category' => 2
    ],
    'audio_selections' => [
        [
                'id' => 'commentary',
                'source' => '$first_audio',
                'source_language' => 1
        ]
    ],
    'processing_profiles' => [
        [
                'id' => 'dubbing',
                'demixing' => 'best_model',
                'transcribing' => 'best_model',
                'translating' => 'best_model',
                'revoicing' => 'best_model'
        ]
    ],
    'pipelines' => [
        [
                'id' => 'spanish',
                'profile' => 'dubbing',
                'audio_selection' => 'commentary',
                'outputs' => [
                                [
                                                                'id' => 'es-audio',
                                                                'kind' => 'audio',
                                                                'language' => 54
                                ],
                                [
                                                                'id' => 'es-subtitle',
                                                                'kind' => 'subtitle',
                                                                'language' => 54
                                ]
                ]
        ]
    ],
    'target_streams' => [
        [
                'id' => 'spanish-out',
                'url' => 'srt://delivery.example.com:9100',
                'type' => 1,
                'inputs' => [
                                [
                                                                'asset_id' => 'es-audio'
                                ],
                                [
                                                                'passthrough_selector' => 'v:0'
                                ]
                ]
        ]
    ]
  ]),
  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;
}

{
  "stream_id": 123,
  "stream_url_for_languages": [
    {
      "languages": [
        123
      ],
      "url": "<string>"
    }
  ],
  "task_id": "<string>",
  "source_publish_url": "<string>"
}

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

Overview

This endpoint is the entry point of the streaming lifecycle. It takes a source feed, one or more processing pipelines, and one or more output destinations, and returns a stream_id you use for every other lifecycle operation.

Supported source protocols: SRT is supported today. RTMP and HLS ingest are coming soon.

How a stream fits together

The request body is built from four blocks that reference each other by id:

Source

source_stream - the live feed to ingest, e.g. srt://ingest.example.com:9000. You can also use the play URL of a stream flow here, or push the feed to Camb.ai with deferred_source_stream instead.

Audio selections

audio_selections - name the audio track(s) of the source you want to process and declare their spoken language. Use Probe a Source Stream to discover tracks, or start with $first_audio.

Profiles and pipelines

processing_profiles define how audio is processed (demixing, transcription, translation, revoicing, each none, best_model, or fast_model). pipelines connect an audio selection to a profile and declare the output assets to produce, each with a language.

Targets

target_streams - where the processed output goes. At least one is required. Push to your own endpoint (SRT/RTMP), or let Camb.ai host the output for you (SRT listener or HLS recording).

Before you start

Collect the IDs the payload references:

Language IDs - GET /source-languages and GET /target-languages. Languages are numeric IDs; for example 1 is English (US) and 54 is Spanish (Spain).

The system handles multilingual inputs. If the source audio mixes several languages, set source_language to the main one spoken; the others are handled automatically.

Voice IDs (optional) - GET /list-voices. If you pass voice IDs, dubbed speech uses those fixed voices. If you leave them out, voices are cloned from the speakers in the source audio.
Dictionary IDs (optional) - GET /dictionaries for custom terminology, up to 5.

When passing fixed voice IDs, include voices of different genders and tones. The system matches each speaker in the source audio to the most suitable voice from your list, so a varied list produces better matches.

A pipeline that produces an audio output must also declare a subtitle output in the same pipeline; the transcript drives the dubbing. You do not have to route the subtitle asset to a target.

Example: dub a football match into Spanish

The example ingests the SRT feed of a football match, dubs the English commentary (1) into Spanish (54), and pushes the dubbed program (original video plus Spanish commentary) to an SRT destination of your own.

Fastest way to test: copy this payload, adjust it to your setup, and paste it into the Try it body - the form fields fill in automatically from the pasted JSON. Then press Send.

curl -X POST "https://client.camb.ai/apis/stream" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Saturday Match Live Dub",
    "description": "Football match commentary dubbed from English into Spanish",
    "end_time": "2026-08-01T21:45:00Z",
    "timezone": "UTC",
    "voices": [12345],
    "source_stream": {
      "id": "match-feed",
      "url": "srt://ingest.example.com:9000",
      "latency": 2000,
      "category": 2
    },
    "audio_selections": [
      {
        "id": "commentary",
        "source": "$first_audio",
        "source_language": 1
      }
    ],
    "processing_profiles": [
      {
        "id": "dubbing",
        "demixing": "best_model",
        "transcribing": "best_model",
        "translating": "best_model",
        "revoicing": "best_model"
      }
    ],
    "pipelines": [
      {
        "id": "spanish",
        "profile": "dubbing",
        "audio_selection": "commentary",
        "outputs": [
          { "id": "es-audio", "kind": "audio", "language": 54 },
          { "id": "es-subtitle", "kind": "subtitle", "language": 54 }
        ]
      }
    ],
    "target_streams": [
      {
        "id": "spanish-out",
        "url": "srt://delivery.example.com:9100",
        "type": 1,
        "inputs": [
          { "asset_id": "es-audio" },
          { "passthrough_selector": "v:0" }
        ]
      }
    ]
  }'

import requests

payload = {
    "name": "Saturday Match Live Dub",
    "description": "Football match commentary dubbed from English into Spanish",
    "end_time": "2026-08-01T21:45:00Z",  # streams always need an end time
    "timezone": "UTC",
    "voices": [12345],  # from GET /list-voices
    "source_stream": {
        "id": "match-feed",
        "url": "srt://ingest.example.com:9000",
        "latency": 2000,  # recommended SRT latency (ms)
        "category": 2,  # sports and entertainment
    },
    "audio_selections": [
        {
            "id": "commentary",
            "source": "$first_audio",
            "source_language": 1,  # English (US)
        }
    ],
    "processing_profiles": [
        {
            "id": "dubbing",
            "demixing": "best_model",
            "transcribing": "best_model",
            "translating": "best_model",
            "revoicing": "best_model",
        }
    ],
    "pipelines": [
        {
            "id": "spanish",
            "profile": "dubbing",
            "audio_selection": "commentary",
            "outputs": [
                {"id": "es-audio", "kind": "audio", "language": 54},  # Spanish (Spain)
                {"id": "es-subtitle", "kind": "subtitle", "language": 54},
            ],
        }
    ],
    "target_streams": [
        {
            "id": "spanish-out",
            "url": "srt://delivery.example.com:9100",
            "type": 1,  # SRT caller: Camb.ai pushes to your endpoint
            "inputs": [
                {"asset_id": "es-audio"},
                {"passthrough_selector": "v:0"},  # forward the original video
            ],
        }
    ],
}

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

response.raise_for_status()
print(response.json())

A successful request returns the stream ID and the output URLs:

{
  "stream_id": 1234,
  "task_id": "b8f2f1f0-3c6a-4f5e-9b2a-1c2d3e4f5a6b",
  "stream_url_for_languages": [
    {
      "languages": [54],
      "url": "srt://delivery.example.com:9100"
    }
  ]
}

Scheduling

Every stream needs an end_time (with its timezone); the stream stops automatically at that moment. start_time is optional: omit it to start right away, or set it to schedule the stream for later.

{
  "start_time": "2026-08-01T19:30:00Z",
  "end_time": "2026-08-01T21:45:00Z",
  "timezone": "UTC"
}

Scheduling rules:

Times are ISO 8601 with a UTC offset, and the timezone (IANA name) must match their offset.
start_time cannot be in the past and at most 7 days in the future.
end_time must be at least 15 minutes after the start.

To end a stream before its end_time, delete it. To extend or shorten a running stream, update its end_time.

Hosted ingest

If your encoder cannot be reached from the internet, or you would rather push than be pulled, replace source_stream with deferred_source_stream. Camb.ai hosts an SRT endpoint for the stream’s ingest and returns its URL as source_publish_url; point your encoder at it (as an SRT caller) once the stream is created.

{
  "deferred_source_stream": { "id": "match-feed", "region": "us-central1" }
}

Response

{
  "stream_id": 1234,
  "task_id": "b8f2f1f0-3c6a-4f5e-9b2a-1c2d3e4f5a6b",
  "source_publish_url": "srt://203.0.113.10:20121?streamid=publish/1234-0/k3yk3yk3yk3yk3yk3yk3yk3yk",
  "stream_url_for_languages": [
    {
      "languages": [54],
      "url": "srt://delivery.example.com:9100"
    }
  ]
}

Set exactly one of source_stream and deferred_source_stream.

Choosing targets

You want to…	Use
Push to your own SRT endpoint	`"type": 1` with your `url`
Push to an RTMP ingest (e.g. YouTube)	`"type": 2` (or `4` for YouTube) with the ingest `url`
Let viewers pull from Camb.ai over SRT	`"type": 6`, omit `url`; the play URL is returned
Get a Camb.ai-hosted HLS recording	`"type": 3`, omit `url`; the playback URL is returned
Serve SRT viewers from a region near them	`"type": 6` with a `region` (see Regions)

Each target lists inputs: pipeline outputs by asset_id, and untouched source tracks by passthrough_selector (e.g. v:0 for the video). Source tracks that are not replaced by a pipeline output are forwarded automatically unless you set passthrough_policy to none.

Regions

Camb.ai-hosted SRT endpoints live in one region each. The hosted ingest (deferred_source_stream.region) and each SRT listener target (target_streams[].region with "type": 6) take a region from List Flow Regions; without one they are hosted in us-central1. One stream can mix regions, for example an ingest and a Spanish output in us-central1 and a French output in europe-west2:

{
  "deferred_source_stream": { "id": "match-feed", "region": "us-central1" },
  "target_streams": [
    { "id": "spanish-viewers", "type": 6, "region": "us-central1", "inputs": [{ "asset_id": "es-audio" }] },
    { "id": "french-viewers", "type": 6, "region": "europe-west2", "inputs": [{ "asset_id": "fr-audio" }] },
    { "id": "recording", "type": 3 }
  ]
}

Region rules:

HLS recording targets ("type": 3) are always served from us-central1. Omit region, or set it to us-central1.
Other target types (SRT caller, RTMP, YouTube, sidecar subtitles) do not take a region.
A region is fixed once the stream is created: the returned URLs carry that region’s address.

Errors

402 - Insufficient credits for the requested configuration.
422 - Validation error: missing required blocks, an id reference that doesn’t resolve (e.g. a pipeline referencing an unknown profile), invalid language IDs, or malformed URLs. Also returned for a region that is not in List Flow Regions (the error names the available regions), a region other than us-central1 on an HLS recording target, and a region on a target type that does not take one.

Probe a Source Stream - inspect the source before creating
Get Stream Status - monitor state and output URLs
Update a Stream - reschedule, reconfigure, or toggle dubbing live
Delete a Stream - terminate a running or scheduled stream
Create an SRT Flow - standing SRT endpoints usable as source or target

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 live stream. Exactly one of source_stream or deferred_source_stream is required.

end_time

string<date-time>

required

When the stream stops, in ISO 8601 with a UTC offset. Required; must be at least 15 minutes after the start. To end a stream earlier, delete it; to change the end, patch it.

timezone

string

required

IANA time zone name (e.g. UTC, Europe/London) that start_time/end_time are expressed in. Its offset must match the timestamps.

audio_selections

AudioSelection · object[]

required

Named audio tracks of the source that pipelines process.

Minimum array length: 1

Hide child attributes

audio_selections.id

string

required

Your identifier for this selection, referenced by pipelines[].audio_selection.

audio_selections.source

string

required

Audio track selector. Accepts FFmpeg-style selectors (a:0, 1, eng, #0x1fe, i:301, optionally with a channel suffix like :ch0,1) or magic selectors ($first_audio, $second_audio, $last_audio). Use Probe a Source Stream to discover tracks.

audio_selections.source_language

integer

required

Language spoken on the selected track. If the audio mixes several languages, use the main one; multilingual input is handled automatically. Numeric language ID from GET /source-languages, e.g. 1 for English (US).

audio_selections.background

string | null

Optional selector (same syntax as source) for a clean background/music track. When set, it is used as the background bed for mixing instead of demixing the source.

processing_profiles

ProcessingProfile · object[]

required

Reusable AI processing configurations referenced by pipelines.

Minimum array length: 1

Hide child attributes

processing_profiles.id

string

required

Your identifier for this profile, referenced by pipelines[].profile.

processing_profiles.demixing

enum<string>

default:none

Separate speech from background music/effects before transcription.

Available options:

none,

best_model,

fast_model

processing_profiles.transcribing

enum<string>

default:none

Speech-to-text on the selected audio.

Available options:

none,

best_model,

fast_model

processing_profiles.translating

enum<string>

default:none

Translate the transcript into each output language.

Available options:

none,

best_model,

fast_model

processing_profiles.revoicing

enum<string>

default:none

Synthesise dubbed speech in the output language.

Available options:

none,

best_model,

fast_model

processing_profiles.mixing

OverdubConfig · object | null

Optional mix gains for dubbed output. Requires revoicing to be enabled.

Hide child attributes

processing_profiles.mixing.original_audio_gain

number | null

Volume of the original speaker while dubbed audio plays (0.0-1.0).

Required range: 0 <= x <= 1

processing_profiles.mixing.background_audio_gain

number | null

Volume of background music/ambience during dubbed segments (0.0-1.0).

Required range: 0 <= x <= 1

processing_profiles.mixing.fallback_audio_gain

number | null

Volume of the original audio while nothing is being dubbed (0.0-1.0).

Required range: 0 <= x <= 1

processing_profiles.mixing.fade_time

number

default:1

Cross-fade duration in seconds when switching between original and dubbed audio (0-5).

Required range: 0 <= x <= 5

processing_profiles.scte35_dubbing_control

Scte35DubbingControl · object | null

Optional automatic dubbing toggling on SCTE-35 ad-break markers.

Hide child attributes

processing_profiles.scte35_dubbing_control.on_out_of_network_start

string | null

default:disabled

Dubbing state applied when an ad break starts.

processing_profiles.scte35_dubbing_control.on_out_of_network_end

string | null

default:enabled

Dubbing state applied when an ad break ends.

pipelines

ProcessingPipeline · object[]

required

Processing pipelines connecting audio selections to profiles and outputs.

Minimum array length: 1

Hide child attributes

pipelines.id

string

required

Your identifier for this pipeline.

pipelines.profile

string

required

id of an entry in processing_profiles.

pipelines.audio_selection

string

required

id of an entry in audio_selections.

pipelines.outputs

PipelineOutput · object[]

required

Assets this pipeline produces. Output ids must be unique across all pipelines.

Minimum array length: 1

Hide child attributes

pipelines.outputs.id

string

required

Your identifier for the produced asset, referenced by target_streams[].inputs[].asset_id.

pipelines.outputs.kind

enum<string>

required

Type of asset to produce.

Available options:

audio,

subtitle,

video,

data

pipelines.outputs.language

integer | null

Language of the asset. Required for audio and subtitle outputs. Numeric language ID. Use GET /source-languages for valid source_language values and GET /target-languages for valid output language values. For example, 1 is English (US) and 54 is Spanish (Spain).

target_streams

TargetStream · object[]

required

Destinations for the processed output. At least one is required.

Minimum array length: 1

Hide child attributes

target_streams.id

string

required

Your identifier for the target, e.g. youtube-es.

target_streams.type

enum<integer>

required

Output protocol/type.

Available options:

1,

2,

3,

4,

5,

6,

11

target_streams.url

string | null

Destination URL to push to. Omit for SRT listener (6) and HLS recording (3) targets - their URLs are generated and returned in the create response and stream status.

target_streams.passthrough_policy

enum<string>

default:all

Which source tracks are forwarded alongside the listed inputs. With all (the default), source tracks not replaced by a pipeline output are forwarded automatically.

Available options:

all,

none

target_streams.inputs

TargetStreamInput · object[]

Tracks to include in this output. May be omitted when passthrough_policy is all or for auto-hosted target types.

Hide child attributes

target_streams.inputs.asset_id

string | null

id of a pipeline output to include.

target_streams.inputs.passthrough_selector

string | null

Selector (e.g. v:0, a:eng) for a source track to forward unprocessed.

target_streams.inputs.pid_policy

enum<string>

default:auto

How the MPEG-TS PID for this track is chosen.

Available options:

preserve,

auto,

explicit

target_streams.inputs.pid

integer | null

Explicit MPEG-TS PID (32-8190). Required when pid_policy is explicit, forbidden otherwise.

Required range: 32 <= x <= 8190

target_streams.inputs.encoding_policy

enum<string>

default:auto

How this track is encoded.

Available options:

preserve,

auto,

explicit

target_streams.inputs.encoding_profile

string | null

id of an entry in encoding_profiles. Required when encoding_policy is explicit, forbidden otherwise.

target_streams.passphrase

string | null

SRT encryption passphrase to use when pushing to the destination.

target_streams.streamid

string | null

SRT streamid to send when connecting to the destination.

target_streams.region

string | null

Used only when the stream is created (POST /stream): the region whose relay serves an SRT listener (6) target, one of GET /flows/regions; defaults to us-central1. HLS recording (3) targets accept only us-central1. On create, a region on any other target type is rejected with 422. PATCH /stream/{stream_id} does not place targets: a region sent there has no effect. To serve a target from another region, create a new stream.

target_streams.constant_bitrate

MPEG-TS constant-bitrate control: false/omitted for variable bitrate, true to derive the mux rate from the source bandwidth, or an explicit rate string such as "500k" or "5M".

target_streams.latency

integer | null

SRT send latency in milliseconds (20-8000). Higher values tolerate more network jitter at the cost of delay. Recommended: 2000 for typical internet links.

Required range: 20 <= x <= 8000

name

string | null

Display name for the stream. Auto-generated if omitted.

description

string | null

Free-form description of the stream.

initial_delay

integer

default:120

Seconds of setup lead time before processing starts. Larger values give the pipeline more headroom to warm up; smaller values start output sooner.

voices

integer[]

Optional voice IDs from GET /list-voices to use for dubbed speech. If provided, these fixed voices are used; if omitted or empty, voices are cloned from the speakers in the source audio. When providing voices, include different genders and tones so each speaker can be matched to the most suitable voice.

dictionaries

integer[]

Optional dictionary IDs for custom terminology (up to 5), from GET /dictionaries.

Maximum array length: 5

start_time

string<date-time> | null

Optional scheduled start in ISO 8601 with a UTC offset, e.g. 2026-08-01T19:30:00Z. If omitted, the stream starts as soon as it is created. Cannot be in the past; at most 7 days in the future.

encoding_profiles

EncodingProfile · object[] | null

Optional reusable encoding configurations referenced by target inputs.

Hide child attributes

encoding_profiles.id

string

required

Your identifier for this profile.

encoding_profiles.audio_codec

string | null

Audio codec, e.g. aac.

encoding_profiles.audio_bitrate

string | null

Audio bitrate, e.g. 192k.

encoding_profiles.audio_channel_layout

string | null

Channel layout, e.g. stereo.

encoding_profiles.video_codec

string | null

Video codec, e.g. h264.

encoding_profiles.video_bitrate

string | null

Video bitrate, e.g. 5M.

source_stream

SourceStream · object

The live source to ingest, pulled from its url. Set this or deferred_source_stream, not both.

Hide child attributes

source_stream.id

string

required

Your identifier for the source stream, e.g. main-feed.

source_stream.url

string

required

URL of the live source to ingest, e.g. srt://ingest.example.com:9000.

source_stream.category

enum<integer> | null

Content category of the source stream, used to tune processing.

Value	Category
`1`	News and information
`2`	Sports and entertainment
`3`	Business and professional
`4`	Education and training
`5`	Events and ceremonies
`6`	Government and official

Available options:

1,

2,

3,

4,

5,

6

source_stream.passphrase

string | null

SRT encryption passphrase for the source, if the source is encrypted (10-79 characters).

Required string length: 10 - 79

source_stream.streamid

string | null

SRT streamid to send when connecting to the source, if it requires one. Not the Camb.ai stream ID.

source_stream.latency

integer | null

SRT receive latency in milliseconds (20-8000). Higher values tolerate more network jitter at the cost of delay. Recommended: 2000 for typical internet links.

Required range: 20 <= x <= 8000

deferred_source_stream

DeferredSourceStream · object

A source you push to Camb.ai instead of one Camb.ai pulls. Camb.ai hosts the stream's ingest and returns its URL as source_publish_url. Set this or source_stream, not both.

Hide child attributes

deferred_source_stream.id

string

required

Your identifier for the source stream, e.g. main-feed.

deferred_source_stream.region

string | null

Region to host the ingest in, one of GET /flows/regions. Defaults to us-central1. Fixed once the stream is created.

Response

Successful Response

stream_id

integer

Identifier of the created stream, used for all lifecycle operations.

stream_url_for_languages

StreamURLForLanguages · object[]

Playback URLs for the outputs, grouped by language.

Hide child attributes

stream_url_for_languages.languages

integer[]

Language IDs available on this output URL.

Numeric language ID. Use GET /source-languages for valid source_language values and GET /target-languages for valid output language values. For example, 1 is English (US) and 54 is Spanish (Spain).

stream_url_for_languages.url

string

URL of this output for the listed languages. For Camb.ai-hosted outputs (SRT listener, HLS recording) this is a playback URL you can distribute; for push outputs it echoes your destination URL.

task_id

string

Identifier of the setup task; useful when contacting support.

source_publish_url

string | null

SRT URL your encoder pushes the source to, when the request used deferred_source_stream. null otherwise.

Last modified on October 23, 2026

Create Stream

curl --request POST \
  --url https://client.camb.ai/apis/stream \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "name": "Saturday Match Live Dub",
  "description": "Football match commentary dubbed from English into Spanish",
  "end_time": "2026-08-01T21:45:00Z",
  "timezone": "UTC",
  "voices": [],
  "source_stream": {
    "id": "match-feed",
    "url": "srt://ingest.example.com:9000",
    "latency": 2000,
    "category": 2
  },
  "audio_selections": [
    {
      "id": "commentary",
      "source": "$first_audio",
      "source_language": 1
    }
  ],
  "processing_profiles": [
    {
      "id": "dubbing",
      "demixing": "best_model",
      "transcribing": "best_model",
      "translating": "best_model",
      "revoicing": "best_model"
    }
  ],
  "pipelines": [
    {
      "id": "spanish",
      "profile": "dubbing",
      "audio_selection": "commentary",
      "outputs": [
        {
          "id": "es-audio",
          "kind": "audio",
          "language": 54
        },
        {
          "id": "es-subtitle",
          "kind": "subtitle",
          "language": 54
        }
      ]
    }
  ],
  "target_streams": [
    {
      "id": "spanish-out",
      "url": "srt://delivery.example.com:9100",
      "type": 1,
      "inputs": [
        {
          "asset_id": "es-audio"
        },
        {
          "passthrough_selector": "v:0"
        }
      ]
    }
  ]
}
'

import requests

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

payload = {
    "name": "Saturday Match Live Dub",
    "description": "Football match commentary dubbed from English into Spanish",
    "end_time": "2026-08-01T21:45:00Z",
    "timezone": "UTC",
    "voices": [],
    "source_stream": {
        "id": "match-feed",
        "url": "srt://ingest.example.com:9000",
        "latency": 2000,
        "category": 2
    },
    "audio_selections": [
        {
            "id": "commentary",
            "source": "$first_audio",
            "source_language": 1
        }
    ],
    "processing_profiles": [
        {
            "id": "dubbing",
            "demixing": "best_model",
            "transcribing": "best_model",
            "translating": "best_model",
            "revoicing": "best_model"
        }
    ],
    "pipelines": [
        {
            "id": "spanish",
            "profile": "dubbing",
            "audio_selection": "commentary",
            "outputs": [
                {
                    "id": "es-audio",
                    "kind": "audio",
                    "language": 54
                },
                {
                    "id": "es-subtitle",
                    "kind": "subtitle",
                    "language": 54
                }
            ]
        }
    ],
    "target_streams": [
        {
            "id": "spanish-out",
            "url": "srt://delivery.example.com:9100",
            "type": 1,
            "inputs": [{ "asset_id": "es-audio" }, { "passthrough_selector": "v:0" }]
        }
    ]
}
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({
    name: 'Saturday Match Live Dub',
    description: 'Football match commentary dubbed from English into Spanish',
    end_time: '2026-08-01T21:45:00Z',
    timezone: 'UTC',
    voices: [],
    source_stream: {
      id: 'match-feed',
      url: 'srt://ingest.example.com:9000',
      latency: 2000,
      category: 2
    },
    audio_selections: [{id: 'commentary', source: '$first_audio', source_language: 1}],
    processing_profiles: [
      {
        id: 'dubbing',
        demixing: 'best_model',
        transcribing: 'best_model',
        translating: 'best_model',
        revoicing: 'best_model'
      }
    ],
    pipelines: [
      {
        id: 'spanish',
        profile: 'dubbing',
        audio_selection: 'commentary',
        outputs: [
          {id: 'es-audio', kind: 'audio', language: 54},
          {id: 'es-subtitle', kind: 'subtitle', language: 54}
        ]
      }
    ],
    target_streams: [
      {
        id: 'spanish-out',
        url: 'srt://delivery.example.com:9100',
        type: 1,
        inputs: [{asset_id: 'es-audio'}, {passthrough_selector: 'v:0'}]
      }
    ]
  })
};

fetch('https://client.camb.ai/apis/stream', 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/stream",
  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([
    'name' => 'Saturday Match Live Dub',
    'description' => 'Football match commentary dubbed from English into Spanish',
    'end_time' => '2026-08-01T21:45:00Z',
    'timezone' => 'UTC',
    'voices' => [
        
    ],
    'source_stream' => [
        'id' => 'match-feed',
        'url' => 'srt://ingest.example.com:9000',
        'latency' => 2000,
        'category' => 2
    ],
    'audio_selections' => [
        [
                'id' => 'commentary',
                'source' => '$first_audio',
                'source_language' => 1
        ]
    ],
    'processing_profiles' => [
        [
                'id' => 'dubbing',
                'demixing' => 'best_model',
                'transcribing' => 'best_model',
                'translating' => 'best_model',
                'revoicing' => 'best_model'
        ]
    ],
    'pipelines' => [
        [
                'id' => 'spanish',
                'profile' => 'dubbing',
                'audio_selection' => 'commentary',
                'outputs' => [
                                [
                                                                'id' => 'es-audio',
                                                                'kind' => 'audio',
                                                                'language' => 54
                                ],
                                [
                                                                'id' => 'es-subtitle',
                                                                'kind' => 'subtitle',
                                                                'language' => 54
                                ]
                ]
        ]
    ],
    'target_streams' => [
        [
                'id' => 'spanish-out',
                'url' => 'srt://delivery.example.com:9100',
                'type' => 1,
                'inputs' => [
                                [
                                                                'asset_id' => 'es-audio'
                                ],
                                [
                                                                'passthrough_selector' => 'v:0'
                                ]
                ]
        ]
    ]
  ]),
  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;
}

{
  "stream_id": 123,
  "stream_url_for_languages": [
    {
      "languages": [
        123
      ],
      "url": "<string>"
    }
  ],
  "task_id": "<string>",
  "source_publish_url": "<string>"
}

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

Getting Started

Models

Tutorials

SDK Guides

Hosting Platforms

Integrations

API Reference

Other Products

Release Logs

Create a Stream

Overview

How a stream fits together

Before you start

Example: dub a football match into Spanish

Scheduling

Hosted ingest

Choosing targets

Regions

Errors

Authorizations

Body

Response

​Overview

​How a stream fits together

​Before you start

​Example: dub a football match into Spanish

​Scheduling

​Hosted ingest

​Choosing targets

​Regions

​Errors

​Related endpoints

Authorizations

Body

Response

Overview

How a stream fits together

Before you start

Example: dub a football match into Spanish

Scheduling

Hosted ingest

Choosing targets

Regions

Errors

Related endpoints