Configuration

GET /api/settings/get

Returns the full Composer settings object as JSON — every public property on Settings.cs (currently ~87 fields covering audio, GPU, project management, render tuning, web API, alarms, autosave, etc.). Use this to snapshot the configured state of a running Composer for diagnostics, configuration drift detection, or to seed a backup.

For the per-property reference (and which properties are runtime-mutable via /api/settings/set), see the settings.xml reference in the docs site.

Parameters: None

Response: 200 OK — JSON object with every setting; deeply nested objects are fully serialised.

GET /api/settings/set

Sets a Composer setting at runtime. Only settings marked with the [ApiSetting] attribute can be modified; all other settings return 403 Forbidden.

Parameters:

Example:

/api/settings/set?property=EnableParallelAudioProcessing&value=true

Response:

• 200 OK — Setting '{name}' set to '{value}' successfully
• 400 Bad Request — Missing parameters, property not found, or conversion error
• 403 Forbidden — Property exists but is not allowed to be modified via the API

GET /api/settings/getjson

Identical behaviour to /api/settings/get — same JSON, same response code. Retained as an alias because some older client integrations call this URL. Prefer /api/settings/get for new code.

Parameters: None

Response: 200 OK — JSON object with every setting (same shape as /api/settings/get).

GET /api/license/get

Returns the current LicenseInformation for this Composer host as JSON — the licence key, customer, type, expiry, plug-in licences, and host-locking flags read from the licence file on disk. Returns the same payload regardless of trial / evaluation / subscription status; callers can inspect IsTrial / LicenseType / Expirydate to differentiate.

For an all-in-one validity verdict (rather than the raw licence content), use /api/license/validate.

Parameters: None

Response: 200 OK — JSON object:

{
  "LicenseKey": "ABCD-1234-…",
  "CompanyName": "RealSprint AB",
  "ProductName": "Vindral Composer",
  "MaxChannels": 4,
  "HostName": "STUDIO-01",
  "HostNameKey": "…",
  "LockedToHostName": true,
  "MaxAssemblyMainVersion": 2,
  "CreatedDate": "2026-01-15T00:00:00",
  "LicenseType": "Subscription",
  "ContactPerson": "ops@example.com",
  "MaxInstances": 1,
  "PushUsageToLicenseServer": true,
  "OnlyVerifyWithLicenseServerAtStart": false,
  "Expirydate": "2027-01-15T00:00:00",
  "Guid": "…",
  "Comment": "(-)",
  "PluginLicenses": [],
  "IsTrial": false,
  "CopyrightInfo": "",
  "ProjectKey": ""
}

GET /api/license/validate

Returns the current local validation state of the licence — a snapshot of the flags Composer maintains in memory. Local check only — this endpoint does not initiate a fresh round-trip to license.vindral.com; it reads the cached state from the most recent server interaction (which Composer performs on its own schedule). Use this as a quick health probe in monitoring or readiness checks.

Parameters: None

Response: 200 OK — JSON object:

{
  "IsTrial": false,
  "IsEvaluation": false,
  "IsValidLicenseFile": true,
  "IsVerifiedByLicenseServer": true,
  "IsPostedToLicensedServer": true,
  "IsExpired": false,
  "IsLocked": false,
  "ChecksumError": false
}

Script structure: legacy globals vs. ES6 modules

Composer's script engine (Jint) supports two modes for the project script. The mode is detected automatically from the file's contents — there is no flag or setting to toggle.

Legacy mode (default). If the main script has no top-level import or export statements, the engine evaluates it as a classic script: top-level function declarations land on the global object, and host code looks them up by name. This is how every existing Composer script works, and nothing in those scripts needs to change.

// Legacy: functions on the global object
var Project = importNamespace('VindralEngine').Project.RunningInstance;

function OnProjectInit() { log("ready"); }
function OnConnectorPing(p) { return "pong:" + p; }

The runtime helper LoadScript("file.js") is still available and inlines the named file (resolved relative to the main script directory) into the same global scope.

Module mode. If the main script contains any top-level import or export, it is loaded as an ES6 module via engine.Modules.Import(...). Module-mode scripts can split code across as many .js files as you want; relative specifiers ("./foo.js", "./util/bar.js") resolve against the main script's directory and a built-in path-traversal guard rejects paths outside that directory.

// main.js (module mode — has `import`/`export`)
import { greet } from "./lib.js";
export { OnConnectorPing } from "./lib.js";   // re-export from a library

export function OnProjectInit() { log("ready"); }
export function OnConnectorGreet(p) { return greet(p); }

// lib.js
export function greet(name) { return "hello " + name; }
export function OnConnectorPing(p) { return "pong:" + p; }

Key rules for module mode:

• Public-surface rule. Entry points the host needs to invoke — OnProjectInit, OnProjectStop, OnRenderFrame, every OnConnector{Name}, and any function called via /api/scriptengine/execute or ScriptOperator.MethodName — must be exported by the main script. To host the implementation in a library, use a re-export (export { OnConnectorPing } from "./lib.js";). A bare import "./lib.js"; (side-effect only) loads the library but its exports stay invisible to the host, so connectors and API calls targeting those names silently miss.
• Host objects stay global. log, DebugLog, jsHelper, Logger, LoadScript, and all AllowClr types (e.g. importNamespace('VindralEngine')) remain on the global object — modules can use them without importing anything. The var Logger=VindralLogLibrary.Logger; legacy stripping is not applied to imported library files; new code should use the global Logger directly.
• Path resolution. Specifiers must be relative paths starting with ./ or ../ (subject to the traversal guard); bare specifiers like "some-package" are not resolved by Composer.
• LoadScript() in module mode. Still works, but logs a warning when called: anything it inlines goes to the global scope and is invisible from inside a module. Prefer import instead.

GET /api/scriptengine/execute

Executes a JavaScript function in the Composer Script Engine. The function's return value shapes the HTTP response using the same contract as /api/connector/trigger — string returns become text/plain, objects/arrays become application/json, and a returned object with a numeric httpStatus lets the script set the response code.

Preconditions:

• EnableScriptEngine must be true
• EnableScriptEngineApiCalls must be true
• Script engine must be initialized without errors

Parameters:

Example:

/api/scriptengine/execute?function=myFunction&parameter=hello
/api/scriptengine/execute?function=setConfig&parameter={"key":"value"}

Response:

• Custom status / body / content type — when the called function returns a usable value (see contract).
• 200 OK — fallback text/html body Successfully invoked function {name}() with parameter: {param} when the function returns nothing.
• 400 Bad Request — Missing function name
• 403 Forbidden — Script engine disabled or API calls not allowed
• 500 Internal Server Error — Script engine error or execution failure