General settings

General settings is the instance-level control surface of Callaba Engine. This is where you inspect the current application state, switch HTTP and HTTPS delivery modes, apply SSL certificates, persist custom settings, and move configuration between environments.

Unlike transport modules, these endpoints change how the engine itself behaves. In practice they matter when a new instance is going live, when a domain or certificate has to be corrected safely, or when one environment should inherit a known-good baseline from another.

Examples by preset

The most useful preset families here are domain and delivery setup, certificate update, custom-settings write, and environment migration through export or import.

{
  "http_modes": [
    { "mode": "HTTPS" },
    { "mode": "HTTP" }
  ],
  "cdn_domain_name": "cdn.example.com",
  "streaming_domain_name": "stream.example.com"
}
{
  "ssl_type": "SSL_TYPE_CUSTOM",
  "ssl_domain_name": "stream.example.com",
  "certificate": "-----BEGIN CERTIFICATE-----...",
  "private_key": "-----BEGIN PRIVATE KEY-----..."
}
{
  "custom_settings": {
    "showBrandName": false,
    "useCustomLogo": true
  }
}

Workflow examples

Bring a new instance online with real domains

Use getAppInfo first, then updateHTTPConfig and, if needed, updateSSLCertificate to move from a raw instance into a domain-backed deployment the team can trust.

Keep instance policy and branding in sync

Use updateCustomSettings when the instance should expose different product-level defaults, branding behavior, or feature behavior that operators should feel consistently across the product.

Move settings between environments

Use exportDb and importDb when a staging or backup environment should inherit a known-good subset of application settings without rebuilding everything by hand.

Get app info
Collapse
POST
/api/application/getAppInfo

Loads the current instance-level configuration and status snapshot.

This is the natural first call for a management client because it tells the team what kind of instance they are actually operating before they change domains, certificates, timing, or imported settings.

Request body parameters
This method has no parameters
Get app info
curl --request POST \
  --url http://localhost/api/application/getAppInfo \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{}'
Response
Identity
name / login / token
mixed

Instance identity fields returned for the current application.

Versioning
app_version / stack_version / node_app
mixed

Current engine version and deployment flavor.

Delivery
http_modes / cdn_domain_name / streaming_domain_name
mixed

Current HTTP and domain configuration returned by the engine.

Custom settings
custom_settings
object

Persisted custom application settings.

Operation result
success
boolean

Successful responses expose success: true.

Response: Get app info
JSON
{
  "app_version": "8.2.p.NDI.pre-aws",
  "stack_version": "8.2",
  "node_app": "NODE_APP_SELF_HOSTED",
  "name": "All-in-one. SaaS",
  "login": "admin",
  "token": "<jwt_token>",
  "custom_settings": {
    "showBrandName": false,
    "useCustomLogo": true
  },
  "http_modes": [
    {
      "mode": "HTTPS"
    },
    {
      "mode": "HTTP"
    }
  ],
  "cdn_domain_name": "cdn.example.com",
  "streaming_domain_name": "stream.example.com",
  "success": true
}
Update HTTP config
Expand
POST
/api/application/updateHTTPConfig

Updates HTTP and HTTPS delivery settings for the instance.

Use this when the instance needs the right public-facing domains and delivery modes before traffic is sent to real users or encoders.

Request body parameters
http_modes[]
array

List of enabled delivery modes. Real product values include HTTP and HTTPS.

cdn_domain_name
string

Domain used for CDN-style delivery references.

streaming_domain_name
string

Domain used for stream-facing URLs.

Update HTTP config
curl --request POST \
  --url http://localhost/api/application/updateHTTPConfig \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "http_modes": [
    {
      "mode": "HTTPS"
    },
    {
      "mode": "HTTP"
    }
  ],
  "cdn_domain_name": "cdn.example.com",
  "streaming_domain_name": "stream.example.com"
}'
Response
success
boolean

The backend confirms that the HTTP configuration update was accepted.

Response: Update HTTP config
JSON
{
  "success": true
}
Update SSL certificate
Expand
POST
/api/application/updateSSLCertificate

Updates the SSL certificate configuration of the instance.

Use this when the engine should switch to a custom certificate, Let's Encrypt flow, or another supported SSL policy so the live domain is safe to expose to real viewers and integrations.

Request body parameters
ssl_type
string

SSL policy to apply. Real product values include custom, self-signed, and Let's Encrypt flows.

ssl_domain_name
string

Domain name that the certificate configuration should protect.

certificate
string

PEM certificate body when the selected SSL mode requires a custom certificate.

private_key
string

Matching PEM private key when the selected SSL mode requires one.

Update SSL certificate
curl --request POST \
  --url http://localhost/api/application/updateSSLCertificate \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "ssl_type": "SSL_TYPE_CUSTOM",
  "ssl_domain_name": "stream.example.com",
  "certificate": "-----BEGIN CERTIFICATE-----...",
  "private_key": "-----BEGIN PRIVATE KEY-----..."
}'
Response
result / success
mixed

The backend confirms whether the SSL update completed successfully.

Response: Update SSL certificate
JSON
{
  "success": true,
  "result": true
}
Update custom settings
Expand
POST
/api/application/updateCustomSettings

Persists custom application settings.

Use this when the instance should consistently present different branding, defaults, or product behavior to operators and viewers instead of relying on one-off manual tweaks.

Request body parameters
custom_settings
object

Object of persisted instance-level feature flags and UI behavior settings.

Update custom settings
curl --request POST \
  --url http://localhost/api/application/updateCustomSettings \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "custom_settings": {
    "showBrandName": false,
    "useCustomLogo": true
  }
}'
Response
success
boolean

The backend confirms that the custom settings write finished successfully.

Response: Update custom settings
JSON
{
  "success": true
}
Import DB
Expand
POST
/api/application/importDb

Imports previously exported application settings from a saved dump file.

Use this when another Callaba environment should inherit a known-good configuration state without recreating it field by field.

Request body parameters
file_path
string

Path to the previously exported dump that should be imported.

Import DB
curl --request POST \
  --url http://localhost/api/application/importDb \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "file_path": "uploads/callaba-dump.gz"
}'
Response
success / app_version
mixed

Import confirmation together with the target application version returned by the engine.

Response: Import DB
JSON
{
  "success": true,
  "app_version": "8.2"
}
Export DB
Expand
POST
/api/application/exportDb

Exports a selected set of module settings into a reusable dump artifact.

This is the companion to importDb and is useful for migration, backup, or handoff between environments.

Request body parameters
modules[]
array

List of module identifiers that should be included in the exported dump.

Export DB
curl --request POST \
  --url http://localhost/api/application/exportDb \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "modules": [
    "MODULE_SRT_SERVERS",
    "MODULE_SRT_ROUTERS",
    "MODULE_RTMP_SERVERS",
    "MODULE_RESTREAM",
    "MODULE_VOD"
  ]
}'
Response
result / success
mixed

Path to the exported dump plus a success-shaped confirmation.

Response: Export DB
JSON
{
  "success": true,
  "result": "uploads/callaba-dump.gz"
}
Update NTP configuration
Expand
POST
/api/application/updateNTPConfiguration

Updates the NTP server used by the instance.

Use this when environment policy or timing accuracy requires a specific time source and the team wants the instance clock to stay predictable across recordings, schedules, and event timing.

Request body parameters
ntp_server
string

NTP hostname that the instance should use as its time source.

Update NTP configuration
curl --request POST \
  --url http://localhost/api/application/updateNTPConfiguration \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "ntp_server": "time.apple.com"
}'
Response
success
boolean

The backend confirms that the NTP configuration update was accepted.

Response: Update NTP configuration
JSON
{
  "success": true
}
Next toPorts