Callaba
Callaba home

Callaba Engine documentation

Use the Callaba Engine API to configure servers, connect media sources, and control production jobs on your Callaba instance. Requests go to your server’s address, not to the Callaba website.

Make a read-only request

Create an API token in General settings. Replace the host and token below to list up to ten configured SRT servers without starting or changing them.

curl --request POST \
  --url https://YOUR_CALLABA_HOST/api/srt-servers/getAll \
  --header 'content-type: application/json' \
  --header 'x-access-token: YOUR_API_TOKEN' \
  --data '{"limit":10,"skip":0,"sort":{"server_created":1}}'

The response is an array of server objects. An empty array means no servers matched the request. See Authorization for token handling and public-method access.

Choose the resource you need to automate

Request examples, parameters, and responses are listed under each method. Creating a saved resource and starting its media process are separate operations where the module exposes both methods.

Workflow examples and help
Multi-module production workflow

Compose ingest, monitoring, recording, and delivery

Build one production control plane in dependency order: receive the contribution feed, expose it to operators, capture it, and create independently observable outputs for each destination.

  1. Create contribution ingestDefine the listener, latency, access policy, and any approved primary/backup routing hosts.POST /api/srt-servers/create
  2. Start and verify the sourceMake the upstream boundary healthy before any dependent resource is started.POST /api/srt-servers/start
  3. Create operator monitoringAdd the reviewed source to an authenticated operator layout.POST /api/multiview/create
  4. Start the operator wallVerify the contribution feed visually before opening capture and delivery branches.POST /api/multiview/start
  5. Create the archive branchBind the documented SRT input preset to the required recording format and retention policy.POST /api/recording/create
  6. Start captureStart the archive branch after operator monitoring confirms usable media.POST /api/recording/start
  7. Create each delivery branchCreate one job per destination with only the remuxing or transcoding that target requires.POST /api/restream/create
  8. Start downstream deliveryStart outputs independently so one destination cannot block the others.POST /api/restream/start
  9. Observe each outputCompare process state, bitrate, and frame cadence per branch during the event.POST /api/restream/getStat

Module ids are not interchangeable. Use the exact input preset and source_id documented by each downstream create method, start upstream dependencies first, and roll back only the failed branch instead of restarting the whole workflow.

Multi-module workflow

Receive SRT, record it, and publish browser playback

Use one Callaba API surface to compose ingest, route control, recording, and browser playback. Build in dependency order, then extend the same workflow with storage, multiview, or restream delivery in cloud or self-hosted deployments.

  1. Create SRT ingestConfigure the listener, latency, access rules, and source routing.POST /api/srt-servers/create
  2. Start and verify ingestStart the server before creating jobs that depend on its live input.POST /api/srt-servers/start
  3. Create the archive jobChoose the SRT server input preset and the required continuous or segmented output.POST /api/recording/create
  4. Start recordingStart capture only after the contribution input is healthy.POST /api/recording/start
  5. Create browser deliveryUse the SRT server input preset, then configure HLS or DASH and viewer access.POST /api/vod/create
  6. Start and test playbackStart the player, verify its runtime status, and test the viewer URL.POST /api/vod/start

Each create response supplies the resource id needed by its start call. Use the input preset documented by the downstream module; do not substitute an id from another resource type.

Church service workflow

Take a church service from ingest to multistream, recording, and playback

Build one repeatable service workflow in dependency order: accept the programme feed, start each destination, retain the service, and publish browser playback.

  1. Create service ingestConfigure the RTMP entry point used by the church encoder.POST /api/rtmp-servers/create
  2. Start and verify ingestStart the server before the encoder connects and confirm the source is healthy.POST /api/rtmp-servers/start
  3. Create each platform destinationCreate one restream job per platform from the reviewed programme input.POST /api/restream/create
  4. Start multistream deliveryStart destinations independently so one platform does not hide another platform's state.POST /api/restream/start
  5. Create the service recordingBind a recording job to the same approved programme source.POST /api/recording/create
  6. Start archive captureStart capture after ingest is stable and retain the returned recording id.POST /api/recording/start
  7. Create church-site playbackConfigure the browser player and its intended viewer access.POST /api/vod/create
  8. Start and test playbackStart the player and test the viewer URL before publishing it.POST /api/vod/start

Create and start each resource with the id returned by its own module. Validate the live input before enabling destinations, recording, or viewer playback.

Sports event workflow

Take a sports event from monitoring to paywall and replay

Compose a venue workflow that keeps the programme visible to operators, records the event, publishes browser playback, and starts controlled group access.

  1. Create venue ingestConfigure the RTMP entry point for the approved event programme.POST /api/rtmp-servers/create
  2. Start programme ingestStart the server and confirm contribution before downstream creation.POST /api/rtmp-servers/start
  3. Create operator monitoringAdd the programme and critical outputs to one event Multiview.POST /api/multiview/create
  4. Start the operator viewStart the wall and verify every required source before opening access.POST /api/multiview/start
  5. Create the event recordingConfigure capture from the approved programme input.POST /api/recording/create
  6. Start event captureStart recording after contribution and monitoring are healthy.POST /api/recording/start
  7. Finalize the recordingStop capture cleanly when the live event ends.POST /api/recording/stop
  8. Read replay mediaRead recordedFiles from the finalized recording before building replay.POST /api/recording/getById
  9. Create event playbackConfigure the live or replay player with the intended access settings.POST /api/vod/create
  10. Start viewer playbackStart the player and verify its viewer URL and runtime state.POST /api/vod/start
  11. Create controlled accessGroup the event player under the reviewed paywall or access policy.POST /api/vod-group/create
  12. Start the access groupStart the group only after playback and external entitlement checks are ready.POST /api/vod-group/start

Stop and read the recording before treating it as replay media. A player group controls access to configured players; it does not replace payment-provider or entitlement validation outside Callaba.

Ask AI