media server logo
Toggle documentation navigation
Callaba home

NDI adapters

Use NDI adapters to publish an SRT, RTMP, or video-call source as a named NDI output for a switcher, graphics system, multiviewer, or control room.

What it doesPublish a source as an NDI output

Choose this whenAn SRT, RTMP, or browser-guest source must appear as a named NDI output.

Use another module whenUse NDI Discovered Devices when the source already exists on the NDI network.

1Choose the source2Name the NDI output3Use it downstream
POST /api/restream/create
9 endpoints

Before you start

All methods require a valid x-access-token. Configure NDI networking first, create the upstream SRT, RTMP, or video-call source, and keep its source ID.

What you can do

  • create and update select the input and assign the NDI device name.
  • getAll, getCount, and getById inspect adapters.
  • start and stop control NDI publication.
  • getStat checks the running process.
  • remove deletes an adapter.

Example workflow

{
  "restream_name": "Remote camera to NDI",
  "input": {
    "input_type": "INPUT_TYPE_SRT_SOFTWARE",
    "input_module_id": "SRT_SERVER_ID"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_NDI_DEVICE",
    "output_settings": {
      "ndi_device_name": "Remote Camera 1"
    }
  },
  "module_name": "MODULE_NDI_ADAPTERS",
  "active": true
}

Create the adapter, start it, confirm runtime statistics, and then select Remote Camera 1 on the receiving NDI system.

Common use cases

  • Bring an SRT field camera into an NDI-based control room.
  • Expose an RTMP venue feed to an NDI graphics workstation.
  • Publish a remote video-call guest as an individually selectable NDI source.

Limits and troubleshooting

The input resource must exist and provide usable media. Device names should be stable and unique enough for operators to identify. A saved adapter is not necessarily running; verify getStat before using it on air.

Next steps

Confirm the output on the receiving NDI system, then connect it to the required switching, monitoring, or recording workflow.

REST solution recipe

Bridge an NDI source into a delivery workflow

Create an adapter from a reviewed NDI source to the required output, start it, and verify the running process.

  1. Create the bridgeChoose the NDI input and the protocol and processing required by the destination.POST /api/restream/create
  2. Start the adapterStart after the NDI source and destination are available.POST /api/restream/start
  3. Verify the processRead the adapter runtime statistics before relying on the output.POST /api/restream/getStat

A successful create response confirms configuration, not media health. Start the resource, then verify its runtime statistics before sending production traffic.

Multi-module workflow

Configure NDI discovery, verify the network view, and publish an NDI output

Apply the instance discovery configuration, confirm expected NDI devices are visible, then turn a supported managed source into a named NDI output and verify the adapter process.

  1. Apply NDI network settingsSet the machine name, discovery servers, explicit source IPs, or the reviewed full JSON configuration.POST /api/devices/updateNDIConfiguration
  2. Verify the device inventoryList the current network view and confirm the expected names and addresses.POST /api/devices/getAll
  3. Check discovery activityConfirm the selected discovered row is currently active before relying on the network path.POST /api/devices/getStat
  4. Create the NDI publisherSelect a supported managed input and configure its OUTPUT_TYPE_NDI_DEVICE name and stream-control settings.POST /api/restream/create
  5. Start NDI deliveryStart the adapter after the managed source and target NDI network are available.POST /api/restream/start
  6. Verify the publisher processRead bitrate, FPS, speed, and progress before handing the NDI name to downstream operators.POST /api/restream/getStat

A discovered-device row proves network visibility; its id is not the adapter input handoff. The released adapter examples accept managed SRT, RTMP GoPro, or conference-participant inputs and publish OUTPUT_TYPE_NDI_DEVICE.

POST
/api/restream/create
API token required

Use this when a managed source must be published on the network as an NDI device for switchers, graphics systems, or other production clients.

The saved bridge uses the restream job fields with an NDI-device output and module_name: MODULE_NDI_ADAPTERS. A vMix Script example is available for operator-driven launches.

Managed ingest to NDI

Use this preset when one managed SRT server should show up as a named Cloud NDI output.

SRT server to NDI device

This is the most direct operator-facing bridge from an existing SRT ingest boundary into an NDI device contract.

SRT server to NDI device
Copy code
curl --request POST \
--url http://localhost/api/restream/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"restream_name": "Camera 1 to Cloud NDI via SRT",
"input": {
"input_type": "INPUT_TYPE_SRT_SOFTWARE",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"input_module_id": "66015d2997300f9385d32c00",
"input_stream_url": "",
"input_stream_listen_port": {},
"input_settings": {},
"input_stream_id": "",
"entity_name": "Camera 1 to Cloud NDI via SRT",
"module_name": "MODULE_RESTREAM"
},
"output": {
"output_type": "OUTPUT_TYPE_NDI_DEVICE",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"output_stream_url": "",
"output_stream_listen_port": {},
"output_settings": {
"ndi_device_name": "Cloud NDI Camera 1",
"timestamp_offset": 0,
"av_stream_control_mode": "AV_STREAM_CONTROL_VIDEO_AUDIO"
},
"output_stream_key": "",
"entity_name": "Camera 1 to Cloud NDI via SRT",
"module_name": "MODULE_RESTREAM"
},
"module_name": "MODULE_NDI_ADAPTERS",
"active": true
}'
RTMP server to NDI device

This is useful for hardware or software sources that already terminate on RTMP inside the platform.

RTMP server to NDI device
Copy code
curl --request POST \
--url http://localhost/api/restream/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"restream_name": "GoPro RTMP to Cloud NDI",
"input": {
"input_type": "INPUT_TYPE_RTMP_GOPRO",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"input_module_id": "66015d2997300f9385d32c10",
"input_stream_url": "",
"input_stream_listen_port": {},
"input_settings": {},
"input_stream_id": "",
"entity_name": "GoPro RTMP to Cloud NDI",
"module_name": "MODULE_RESTREAM"
},
"output": {
"output_type": "OUTPUT_TYPE_NDI_DEVICE",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"output_stream_url": "",
"output_stream_listen_port": {},
"output_settings": {
"ndi_device_name": "Cloud NDI GoPro",
"timestamp_offset": 0,
"av_stream_control_mode": "AV_STREAM_CONTROL_VIDEO_AUDIO"
},
"output_stream_key": "",
"entity_name": "GoPro RTMP to Cloud NDI",
"module_name": "MODULE_RESTREAM"
},
"module_name": "MODULE_NDI_ADAPTERS",
"active": true
}'
Realtime participant to NDI

Use this preset when one participant feed from a video call should be surfaced back into an NDI-aware production environment.

Conference participant to NDI device

This is the conference-side variant of the same adapter pattern.

Conference participant to NDI device
Copy code
curl --request POST \
--url http://localhost/api/restream/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"restream_name": "Speaker feed to Cloud NDI",
"input": {
"input_type": "INPUT_TYPE_MODULE_CONFERENCES_PARTICIPANT",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"input_module_id": "66015d2997300f9385d32c20",
"input_stream_url": "",
"input_stream_listen_port": {},
"input_settings": {},
"input_stream_id": "",
"entity_name": "Speaker feed to Cloud NDI",
"module_name": "MODULE_RESTREAM"
},
"output": {
"output_type": "OUTPUT_TYPE_NDI_DEVICE",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"output_stream_url": "",
"output_stream_listen_port": {},
"output_settings": {
"ndi_device_name": "Cloud NDI Speaker",
"timestamp_offset": 0,
"av_stream_control_mode": "AV_STREAM_CONTROL_VIDEO_AUDIO"
},
"output_stream_key": "",
"entity_name": "Speaker feed to Cloud NDI",
"module_name": "MODULE_RESTREAM"
},
"module_name": "MODULE_NDI_ADAPTERS",
"active": true
}'
Request body parameters
Identity
restream_name
string
Copy direct link

Dashboard label: Adapter name.

Human-facing name of the NDI adapter job.

Source
input.input_type
string
Copy direct link

Dashboard label: Source Input.

Real supported runtime families include managed SRT server inputs, managed RTMP server inputs, and conference-participant inputs.

input.input_module_id
string
Copy direct link

Identifier of the selected source entity in the create form.

Destination
output.output_type
string
Copy direct link

Dashboard label: Target Output.

This module pins the output side to OUTPUT_TYPE_NDI_DEVICE.

output.output_settings.ndi_device_name
string
Copy direct link

Dashboard label: NDI® Device Name.

Name of the Cloud NDI output device to create.

output.output_settings.timestamp_offset
integer
Copy direct link

Dashboard label: Timestamp offset (ns).

Optional timestamp shift in nanoseconds.

output.output_settings.av_stream_control_mode
string
Copy direct link

Dashboard label: AV Stream Control.

Controls whether the adapter should publish audio, video, or both.

Runtime
module_name
string
Copy direct link

The UI saves this job as MODULE_NDI_ADAPTERS even though it uses the restream backend paths.

active
boolean
Copy direct link

Dashboard label: Enable once created.

Controls whether the adapter should start active.

Create NDI adapter
Copy code
curl --request POST \
--url http://localhost/api/restream/create \
--header 'x-access-token: <your_api_token>' \
--header 'Content-Type: application/json' \
--data '{
"restream_name": "Camera 1 to Cloud NDI via SRT",
"input": {
"input_type": "INPUT_TYPE_SRT_SOFTWARE",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"input_module_id": "66015d2997300f9385d32c00",
"input_stream_url": "",
"input_stream_listen_port": {},
"input_settings": {},
"input_stream_id": "",
"entity_name": "Camera 1 to Cloud NDI via SRT",
"module_name": "MODULE_RESTREAM"
},
"output": {
"output_type": "OUTPUT_TYPE_NDI_DEVICE",
"application": "IO_APPLICATION_CALLABA_CLOUD_INGRESS_API",
"output_stream_url": "",
"output_stream_listen_port": {},
"output_settings": {
"ndi_device_name": "Cloud NDI Camera 1",
"timestamp_offset": 0,
"av_stream_control_mode": "AV_STREAM_CONTROL_VIDEO_AUDIO"
},
"output_stream_key": "",
"entity_name": "Camera 1 to Cloud NDI via SRT",
"module_name": "MODULE_RESTREAM"
},
"module_name": "MODULE_NDI_ADAPTERS",
"active": true
}'
Response
Identity
_id / id / restream_name
mixed
Copy direct link

Identifiers and the saved adapter name.

Source
input[]
array
Copy direct link

Saved source definition for the adapter.

Destination
output[]
array
Copy direct link

Saved NDI output definition for the adapter.

Runtime
module_name / active / created / modified
mixed
Copy direct link

Module marker, active state, and backend-managed timestamps.

Operation result
success
boolean
Copy direct link

The model exposes success: true for successful responses.

Response: Create NDI adapter
JSON
Copy code
{
"_id": "67f200000000000000000001",
"id": "67f200000000000000000001",
"restream_name": "Camera 1 to Cloud NDI via SRT",
"input": [
{
"_id": "67f200000000000000000010",
"id": "67f200000000000000000010",
"input_type": "INPUT_TYPE_SRT_SOFTWARE",
"input_module_id": "66015d2997300f9385d32c00",
"module_name": "MODULE_RESTREAM"
}
],
"output": [
{
"_id": "67f200000000000000000020",
"id": "67f200000000000000000020",
"output_type": "OUTPUT_TYPE_NDI_DEVICE",
"output_settings": {
"ndi_device_name": "Cloud NDI Camera 1",
"timestamp_offset": 0,
"av_stream_control_mode": "AV_STREAM_CONTROL_VIDEO_AUDIO"
},
"module_name": "MODULE_RESTREAM"
}
],
"module_name": "MODULE_NDI_ADAPTERS",
"active": true,
"created": "2026-03-24T11:00:00.000Z",
"modified": "2026-03-24T11:00:00.000Z",
"success": true
}
POST
/api/restream/getCount
API token required
POST
/api/restream/getAll
API token required
POST
/api/restream/getById
API token required
POST
/api/restream/update
API token required
POST
/api/restream/start
API token required
POST
/api/restream/stop
API token required
DELETE
/api/restream/remove
API token required
POST
/api/restream/getStat
API token required