Developer
Log in

Actions

Output

30 actions in the Output group. Each is its own JSON-RPC method, and also runs through action.run.

output.screenshotScreenshot

Saves a picture (PNG or JPEG) of what's on air, a scene, one source, or the capture(s) showing, at full resolution, in Studio's screenshot folder or one you choose.

Keyscope: control

Parameters

  • ofchoiceoptional

    What to take a picture of. captures: each capture card, game, window or display capture showing (one a capture above covers isn't), one file each at its own full resolution.

    One of program scene source captures · Default "program"

  • scenesceneoptional

    The scene, when of is scene; with of captures, the scene to look in (what's on air when left out). Give its id or name.

    Choices in scenes

  • sourcesourceoptional

    The source, when of is source. Give its id or name.

    Choices in sources

  • foldertextoptional

    A full path to save into; Studio's screenshot folder when left out.

    Up to 4096 characters

  • namechoiceoptional

    The file name: by date and time, random, or your own pattern.

    One of date random pattern · Default "date"

  • patterntextoptional

    With name pattern: words plus {date} {time} {what} {title} {category} {random}.

    Up to 200 characters

  • formatchoiceoptional

    PNG (lossless) or JPEG (smaller).

    One of png jpeg · Default "png"

  • qualityintegeroptional

    JPEG quality (default 90).

    1 to 100

  • fit_widthintegeroptional

    Scale down to fit this width (with fit_height); full resolution when left out.

    16 to 16384 px

  • fit_heightintegeroptional

    Scale down to fit this height (with fit_width).

    16 to 16384 px

Result

  • pathstringalways

    Where the picture was saved (with of captures, the first one).

  • pathsarray of stringalways

    Every file saved: one, or one per capture showing (left to right) with of captures.

Live state

This action has no live state.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "output.screenshot"
}

In the SDKs

C#
Task<OutputScreenshotResult> OutputScreenshotAsync(CancellationToken cancellationToken = default)
Python
async def output_screenshot(self, *, fit_height: int | None = None, fit_width: int | None = None, folder: str | None = None, format: OutputScreenshotFormat | None = None, name: OutputScreenshotName | None = None, of: OutputScreenshotOf | None = None, pattern: str | None = None, quality: int | None = None, scene: str | None = None, source: str | None = None) -> OutputScreenshotResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "fit_height": {
        "description": "Scale down to fit this height (with fit_width).",
        "maximum": 16384,
        "minimum": 16,
        "type": "integer"
      },
      "fit_width": {
        "description": "Scale down to fit this width (with fit_height); full resolution when left out.",
        "maximum": 16384,
        "minimum": 16,
        "type": "integer"
      },
      "folder": {
        "description": "A full path to save into; Studio's screenshot folder when left out.",
        "maxLength": 4096,
        "type": "string"
      },
      "format": {
        "default": "png",
        "description": "PNG (lossless) or JPEG (smaller).",
        "enum": [
          "png",
          "jpeg"
        ],
        "type": "string"
      },
      "name": {
        "default": "date",
        "description": "The file name: by date and time, random, or your own pattern.",
        "enum": [
          "date",
          "random",
          "pattern"
        ],
        "type": "string"
      },
      "of": {
        "default": "program",
        "description": "What to take a picture of. captures: each capture card, game, window or display capture showing (one a capture above covers isn't), one file each at its own full resolution.",
        "enum": [
          "program",
          "scene",
          "source",
          "captures"
        ],
        "type": "string"
      },
      "pattern": {
        "description": "With name pattern: words plus {date} {time} {what} {title} {category} {random}.",
        "maxLength": 200,
        "type": "string"
      },
      "quality": {
        "description": "JPEG quality (default 90).",
        "maximum": 100,
        "minimum": 1,
        "type": "integer"
      },
      "scene": {
        "description": "The scene, when of is scene; with of captures, the scene to look in (what's on air when left out). Give its id or name.",
        "minLength": 1,
        "type": "string"
      },
      "source": {
        "description": "The source, when of is source. Give its id or name.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "path": {
        "description": "Where the picture was saved (with of captures, the first one).",
        "type": "string"
      },
      "paths": {
        "description": "Every file saved: one, or one per capture showing (left to right) with of captures.",
        "items": {
          "type": "string"
        },
        "type": "array"
      }
    },
    "required": [
      "path",
      "paths"
    ],
    "type": "object"
  }
}

record.startStart recording

Starts recording what's on air to a file.

Keyscope: broadcast

Parameters

  • canvaschoiceoptional

    Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.

    One of main vertical both

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • recordingbooleanalways

    On while recording.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

record.recording bool

On while recording. From the record topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "record.start"
}

In the SDKs

C#
Task<RecordStartResult> RecordStartAsync(CancellationToken cancellationToken = default)
Python
async def record_start(self, *, canvas: RecordStartCanvas | None = None) -> RecordStartResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "canvas": {
        "description": "Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.",
        "enum": [
          "main",
          "vertical",
          "both"
        ],
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "recording": {
        "description": "On while recording.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "recording",
      "changed"
    ],
    "type": "object"
  }
}

record.stopStop recording

Stops the recording and saves the file.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • recordingbooleanalways

    On while recording.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

record.recording bool

On while recording. From the record topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "record.stop"
}

In the SDKs

C#
Task<RecordStopResult> RecordStopAsync(CancellationToken cancellationToken = default)
TypeScript
recordStop(): Promise<RecordStopResult>
Python
async def record_stop(self) -> RecordStopResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "recording": {
        "description": "On while recording.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "recording",
      "changed"
    ],
    "type": "object"
  }
}

record.toggleRecord

Starts recording, or stops it if it's running.

Keyscope: broadcast

Parameters

  • canvaschoiceoptional

    Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.

    One of main vertical both

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • recordingbooleanalways

    On while recording.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

record.recording bool

On while recording. From the record topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "record.toggle"
}

In the SDKs

C#
Task<RecordToggleResult> RecordToggleAsync(CancellationToken cancellationToken = default)
Python
async def record_toggle(self, *, canvas: RecordToggleCanvas | None = None) -> RecordToggleResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "canvas": {
        "description": "Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.",
        "enum": [
          "main",
          "vertical",
          "both"
        ],
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "recording": {
        "description": "On while recording.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "recording",
      "changed"
    ],
    "type": "object"
  }
}

record.pausePause recording

Pauses the recording, resumes it, or toggles. The file carries on in one piece when it resumes: no gap, sound and picture together, and its length leaves the paused time out.

Keyscope: broadcast

Parameters

  • modechoiceoptional

    On (pause), off (resume), or toggle.

    One of on off toggle · Default "toggle"

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • pausedbooleanalways

    On while the recording is paused.

Live state

record.paused bool

On while the recording is paused. From the record topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "record.pause"
}

In the SDKs

C#
Task<RecordPauseResult> RecordPauseAsync(CancellationToken cancellationToken = default)
Python
async def record_pause(self, *, mode: RecordPauseMode | None = None) -> RecordPauseResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "mode": {
        "default": "toggle",
        "description": "On (pause), off (resume), or toggle.",
        "enum": [
          "on",
          "off",
          "toggle"
        ],
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "paused": {
        "description": "On while the recording is paused.",
        "type": "boolean"
      }
    },
    "required": [
      "paused",
      "changed"
    ],
    "type": "object"
  }
}

replay.startStart replay buffer

Starts keeping the last seconds of what's on air in memory (as long as Studio's replay buffer setting says), ready for Save replay.

Keyscope: broadcast

Parameters

  • canvaschoiceoptional

    Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.

    One of main vertical both

Result

  • activebooleanalways

    On while the replay buffer runs.

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

replay.active bool

On while the replay buffer runs. From the replay topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "replay.start"
}

In the SDKs

C#
Task<ReplayStartResult> ReplayStartAsync(CancellationToken cancellationToken = default)
Python
async def replay_start(self, *, canvas: ReplayStartCanvas | None = None) -> ReplayStartResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "canvas": {
        "description": "Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.",
        "enum": [
          "main",
          "vertical",
          "both"
        ],
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "active": {
        "description": "On while the replay buffer runs.",
        "type": "boolean"
      },
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "active",
      "changed"
    ],
    "type": "object"
  }
}

replay.stopStop replay buffer

Stops the replay buffer; what it held is let go.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • activebooleanalways

    On while the replay buffer runs.

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

replay.active bool

On while the replay buffer runs. From the replay topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "replay.stop"
}

In the SDKs

C#
Task<ReplayStopResult> ReplayStopAsync(CancellationToken cancellationToken = default)
TypeScript
replayStop(): Promise<ReplayStopResult>
Python
async def replay_stop(self) -> ReplayStopResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "active": {
        "description": "On while the replay buffer runs.",
        "type": "boolean"
      },
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "active",
      "changed"
    ],
    "type": "object"
  }
}

replay.toggleReplay buffer

Starts the replay buffer, or stops it if it's running.

Keyscope: broadcast

Parameters

  • canvaschoiceoptional

    Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.

    One of main vertical both

Result

  • activebooleanalways

    On while the replay buffer runs.

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

replay.active bool

On while the replay buffer runs. From the replay topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "replay.toggle"
}

In the SDKs

C#
Task<ReplayToggleResult> ReplayToggleAsync(CancellationToken cancellationToken = default)
Python
async def replay_toggle(self, *, canvas: ReplayToggleCanvas | None = None) -> ReplayToggleResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "canvas": {
        "description": "Main (landscape), vertical (portrait), or both in separate files. Studio's setting when left out.",
        "enum": [
          "main",
          "vertical",
          "both"
        ],
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "active": {
        "description": "On while the replay buffer runs.",
        "type": "boolean"
      },
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "active",
      "changed"
    ],
    "type": "object"
  }
}

replay.saveSave replay

Saves the replay buffer's last seconds to an MP4, in the replay buffer's folder (Studio's recordings folder) or one you choose, named like screenshots. Returns where it went.

Keyscope: control

Parameters

  • foldertextoptional

    A full path to save into; the replay buffer's folder when left out.

    Up to 4096 characters

  • namechoiceoptional

    The file name: by date and time, random, or your own pattern; as the replay buffer is set up when left out.

    One of date random pattern

  • patterntextoptional

    With name pattern: words plus {date} {time} {what} {title} {category} {random}.

    Up to 200 characters

Result

SavedReplay

  • bytesintegeralways

    Its size.

  • framesintegeroptional

    Video frames in it.

  • pathstringalways

    Where the replay was saved.

  • secondsnumberalways

    Its length.

  • vertical_pathstringoptionalcan be null

    The portrait file when both canvases were saved.

Live state

replay.last_saved string

Where the newest replay went (null before the first). From the replay topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "replay.save"
}

In the SDKs

C#
Task<SavedReplay> ReplaySaveAsync(CancellationToken cancellationToken = default)
Python
async def replay_save(self, *, folder: str | None = None, name: ReplaySaveName | None = None, pattern: str | None = None) -> SavedReplay
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "folder": {
        "description": "A full path to save into; the replay buffer's folder when left out.",
        "maxLength": 4096,
        "type": "string"
      },
      "name": {
        "description": "The file name: by date and time, random, or your own pattern; as the replay buffer is set up when left out.",
        "enum": [
          "date",
          "random",
          "pattern"
        ],
        "type": "string"
      },
      "pattern": {
        "description": "With name pattern: words plus {date} {time} {what} {title} {category} {random}.",
        "maxLength": 200,
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "bytes": {
        "description": "Its size.",
        "type": "integer"
      },
      "frames": {
        "description": "Video frames in it.",
        "type": "integer"
      },
      "path": {
        "description": "Where the replay was saved.",
        "type": "string"
      },
      "seconds": {
        "description": "Its length.",
        "type": "number"
      },
      "vertical_path": {
        "description": "The portrait file when both canvases were saved.",
        "type": [
          "string",
          "null"
        ]
      }
    },
    "required": [
      "path",
      "seconds",
      "bytes"
    ],
    "title": "SavedReplay",
    "type": "object"
  }
}

stream.goliveGo live

Goes live to every destination that's on, or to the one given. Already live, it starts the destinations that are on (or the one given) but not live yet, beside the others, and says which it started.

Keyscope: broadcast

Parameters

  • destinationdestinationoptional

    Where to go live; the selected destination when left out. Give its id from the destinations topic.

    Choices in destinations

Result

  • already_livearray of stringoptional

    Already live: the destinations asked for that were going out already.

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • failedmap of id → stringoptional

    Already live: the destinations that didn't start, with why.

  • livebooleanalways

    On while live.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional
  • startedarray of stringoptional

    Already live: the destinations it started now, beside the others.

Live state

stream.live bool

On while live (connecting and reconnecting count). From the stream topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "stream.golive"
}

In the SDKs

C#
Task<StreamGoliveResult> StreamGoliveAsync(CancellationToken cancellationToken = default)
Python
async def stream_golive(self, *, destination: str | None = None) -> StreamGoliveResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "destination": {
        "description": "Where to go live; the selected destination when left out. Give its id from the destinations topic.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "already_live": {
        "description": "Already live: the destinations asked for that were going out already.",
        "items": {
          "type": "string"
        },
        "type": "array"
      },
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "failed": {
        "additionalProperties": {
          "type": "string"
        },
        "description": "Already live: the destinations that didn't start, with why.",
        "type": "object"
      },
      "live": {
        "description": "On while live.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      },
      "started": {
        "description": "Already live: the destinations it started now, beside the others.",
        "items": {
          "type": "string"
        },
        "type": "array"
      }
    },
    "required": [
      "live",
      "changed"
    ],
    "type": "object"
  }
}

stream.stopEnd stream

Ends the stream. Viewers see it end, so it needs "confirm": true; a key should also ask for a long press.

Keydestructivescope: broadcast

Parameters

  • confirmboolrequired

    Must be true.

    Must be true

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • livebooleanalways

    On while live.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

stream.live bool

On while live. From the stream topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "stream.stop",
  "params": {
    "confirm": true
  }
}

In the SDKs

C#
Task<StreamStopResult> StreamStopAsync(StreamStopParams parameters, CancellationToken cancellationToken = default)
TypeScript
streamStop(params: StreamStopParams): Promise<StreamStopResult>
Python
async def stream_stop(self, *, confirm: bool) -> StreamStopResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "confirm": {
        "const": true,
        "description": "Must be true.",
        "type": "boolean"
      }
    },
    "required": [
      "confirm"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "live": {
        "description": "On while live.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "live",
      "changed"
    ],
    "type": "object"
  }
}

destination.selectSelect destination

Chooses where Go live sends the stream.

Keyscope: broadcast

Parameters

Result

  • selectedstringalways

    The id of the selected destination.

Live state

destinations.items[destination].selected bool

On while this destination is the selected one. From the destinations topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "destination.select",
  "params": {
    "destination": "<destination id>"
  }
}

In the SDKs

C#
Task<DestinationSelectResult> DestinationSelectAsync(DestinationSelectParams parameters, CancellationToken cancellationToken = default)
TypeScript
destinationSelect(params: DestinationSelectParams): Promise<DestinationSelectResult>
Python
async def destination_select(self, *, destination: str) -> DestinationSelectResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "destination": {
        "description": "The destination. Give its id from the destinations topic.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [
      "destination"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "selected": {
        "description": "The id of the selected destination.",
        "type": "string"
      }
    },
    "required": [
      "selected"
    ],
    "type": "object"
  }
}

destination.startGo live on a destination

Starts the stream to one destination. While live, it joins the destinations already going out (the others carry on); offline, Studio goes live to it alone.

Keyscope: broadcast

Parameters

Result

  • already_livearray of stringoptional

    The destinations that were going out already.

  • changedbooleanalways

    False when it was going to this destination already.

  • destinationstringalways

    The destination's id.

  • failedmap of id → stringoptional

    The destinations that didn't start, with why.

  • livebooleanalways

    On: the stream is going out.

  • resultOutputReportoptional

    What the output reported.

    Fields of result
    • okbooleanoptional
    • pathstringoptional
  • startedarray of stringoptional

    The destinations it started.

Live state

destinations.items[destination].live bool

On while the stream is going to this destination. From the destinations topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "destination.start",
  "params": {
    "destination": "<destination id>"
  }
}

In the SDKs

C#
Task<DestinationStartResult> DestinationStartAsync(DestinationStartParams parameters, CancellationToken cancellationToken = default)
TypeScript
destinationStart(params: DestinationStartParams): Promise<DestinationStartResult>
Python
async def destination_start(self, *, destination: str) -> DestinationStartResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "destination": {
        "description": "The destination. Give its id from the destinations topic.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [
      "destination"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "already_live": {
        "description": "The destinations that were going out already.",
        "items": {
          "type": "string"
        },
        "type": "array"
      },
      "changed": {
        "description": "False when it was going to this destination already.",
        "type": "boolean"
      },
      "destination": {
        "description": "The destination's id.",
        "type": "string"
      },
      "failed": {
        "additionalProperties": {
          "type": "string"
        },
        "description": "The destinations that didn't start, with why.",
        "type": "object"
      },
      "live": {
        "description": "On: the stream is going out.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      },
      "started": {
        "description": "The destinations it started.",
        "items": {
          "type": "string"
        },
        "type": "array"
      }
    },
    "required": [
      "destination",
      "live",
      "changed"
    ],
    "type": "object"
  }
}

destination.stopEnd a destination's stream

Ends the stream to one destination at once; the others carry on (ending the only one ends the stream). Its viewers see the stream end, so it needs "confirm": true.

Keydestructivescope: broadcast

Parameters

  • destinationdestinationrequired

    The destination. Give its id from the destinations topic.

    Choices in destinations

  • confirmboolrequired

    Must be true.

    Must be true

Result

  • changedbooleanalways

    False when it wasn't going to this destination.

  • destinationstringalways

    The destination's id.

  • livebooleanalways

    Whether the stream goes to this destination now (false).

  • resultOutputReportoptional

    Its final status.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

destinations.items[destination].live bool

On while the stream is going to this destination. From the destinations topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "destination.stop",
  "params": {
    "destination": "<destination id>",
    "confirm": true
  }
}

In the SDKs

C#
Task<DestinationStopResult> DestinationStopAsync(DestinationStopParams parameters, CancellationToken cancellationToken = default)
TypeScript
destinationStop(params: DestinationStopParams): Promise<DestinationStopResult>
Python
async def destination_stop(self, *, confirm: bool, destination: str) -> DestinationStopResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "confirm": {
        "const": true,
        "description": "Must be true.",
        "type": "boolean"
      },
      "destination": {
        "description": "The destination. Give its id from the destinations topic.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [
      "destination",
      "confirm"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it wasn't going to this destination.",
        "type": "boolean"
      },
      "destination": {
        "description": "The destination's id.",
        "type": "string"
      },
      "live": {
        "description": "Whether the stream goes to this destination now (false).",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "Its final status.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "destination",
      "live",
      "changed"
    ],
    "type": "object"
  }
}

destination.reconnectReconnect a destination

Drops one live destination's connection and publishes there again at once, as a fresh start does; the others and the broadcast carry on. For a platform that shows a stream error while Studio says it's live. Does nothing when the stream isn't going to it.

Keyscope: broadcast

Parameters

Result

  • changedbooleanalways

    False when the stream wasn't going to this destination.

  • destinationstringalways

    The destination's id.

  • reconnectingbooleanalways

    On: its connection was dropped and it's publishing again.

  • resultOutputReportoptional

    What the output reported.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

destinations.items[destination].live bool

On while the stream is going to this destination. From the destinations topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "destination.reconnect",
  "params": {
    "destination": "<destination id>"
  }
}

In the SDKs

C#
Task<DestinationReconnectResult> DestinationReconnectAsync(DestinationReconnectParams parameters, CancellationToken cancellationToken = default)
TypeScript
destinationReconnect(params: DestinationReconnectParams): Promise<DestinationReconnectResult>
Python
async def destination_reconnect(self, *, destination: str) -> DestinationReconnectResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "destination": {
        "description": "The destination. Give its id from the destinations topic.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [
      "destination"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when the stream wasn't going to this destination.",
        "type": "boolean"
      },
      "destination": {
        "description": "The destination's id.",
        "type": "string"
      },
      "reconnecting": {
        "description": "On: its connection was dropped and it's publishing again.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "destination",
      "reconnecting",
      "changed"
    ],
    "type": "object"
  }
}

destination.audioAudio sent

Chooses what a destination's live audio is: full (the stream's full mix, the default) or vod_safe (without the sources marked Live only, such as music and alerts, which keeps them out of that platform's VOD; its live viewers don't hear them either). For platforms and custom servers; Velora takes none (it leaves Live-only sources out of its VOD itself). Applies the next time it goes live.

Keyscope: broadcast

Parameters

  • destinationdestinationrequired

    The destination (not Velora). Give its id from the destinations topic.

    Choices in destinations

  • audiochoicerequired

    full or vod_safe.

    One of full vod_safe

Result

  • audio_mixAudioMix (string)always

    What it sends now, from its next go live: full or vod_safe (without Live-only sources).

    One of "full" "vod_safe"

  • changedbooleanalways

    Whether this changed it.

  • destinationstringalways

    The destination's id.

Live state

destinations.items[destination].audio_mix string

full or vod_safe (null for Velora). From the destinations topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "destination.audio",
  "params": {
    "destination": "<destination id>",
    "audio": "full"
  }
}

In the SDKs

C#
Task<DestinationAudioResult> DestinationAudioAsync(DestinationAudioParams parameters, CancellationToken cancellationToken = default)
TypeScript
destinationAudio(params: DestinationAudioParams): Promise<DestinationAudioResult>
Python
async def destination_audio(self, *, audio: AudioMix, destination: str) -> DestinationAudioResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "audio": {
        "description": "full or vod_safe.",
        "enum": [
          "full",
          "vod_safe"
        ],
        "type": "string"
      },
      "destination": {
        "description": "The destination (not Velora). Give its id from the destinations topic.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [
      "destination",
      "audio"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "audio_mix": {
        "description": "What it sends now, from its next go live: full or vod_safe (without Live-only sources).",
        "enum": [
          "full",
          "vod_safe"
        ],
        "title": "AudioMix",
        "type": "string"
      },
      "changed": {
        "description": "Whether this changed it.",
        "type": "boolean"
      },
      "destination": {
        "description": "The destination's id.",
        "type": "string"
      }
    },
    "required": [
      "destination",
      "audio_mix",
      "changed"
    ],
    "type": "object"
  }
}

destination.healthDestination health

Shows a destination's own state and health, while multistreaming too: offline, connecting, live, reconnecting or error (with why), with bitrate, packet loss, round trip and reconnects while live.

Displayscope: control

Parameters

Result

A DestinationHealth. See its fields under Shapes.

Live state

destinations.items[destination].health object

{state, error, note, kbps, send_kbps, fps, loss, rtt_ms, reconnects, reconnect_attempt, seconds, protocol, frames_published, frames_dropped, dropped}; state is offline, connecting, live, reconnecting or error (with error saying why); protocol is how it's sent (whip, veloq, rtmps, rtmp, srt). From the destinations topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "destination.health",
  "params": {
    "destination": "<destination id>"
  }
}

In the SDKs

C#
Task<DestinationHealth> DestinationHealthAsync(DestinationHealthParams parameters, CancellationToken cancellationToken = default)
TypeScript
destinationHealth(params: DestinationHealthParams): Promise<DestinationHealth>
Python
async def destination_health(self, *, destination: str) -> DestinationHealth
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "destination": {
        "description": "The destination. Give its id from the destinations topic.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [
      "destination"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "delay_secs": {
        "description": "The stream delay in seconds (0: none): viewers see everything this much later.",
        "type": [
          "integer",
          "null"
        ]
      },
      "delay_starts_in": {
        "description": "Seconds until viewers see the first of a delayed stream; 0 once they do.",
        "type": [
          "integer",
          "null"
        ]
      },
      "dropped": {
        "description": "Frames Studio dropped before sending.",
        "type": [
          "number",
          "null"
        ]
      },
      "error": {
        "description": "Why it stopped going out (state error: refused, failed, or stopped with an error).",
        "type": [
          "string",
          "null"
        ]
      },
      "fps": {
        "description": "Frames per second being sent, while live.",
        "type": [
          "number",
          "null"
        ]
      },
      "frames_dropped": {
        "description": "Frames the sending library lost (VELoQ): ones the ingest subscribed to and never got. Frames for tracks not subscribed yet, or before a video track's first keyframe, are not counted.",
        "type": [
          "number",
          "null"
        ]
      },
      "frames_published": {
        "description": "Frames handed to the network so far (VELoQ).",
        "type": [
          "number",
          "null"
        ]
      },
      "kbps": {
        "description": "The bitrate in kbit/s, while live.",
        "type": [
          "number",
          "null"
        ]
      },
      "loss": {
        "description": "Packet loss, 0 to 1, while live.",
        "type": [
          "number",
          "null"
        ]
      },
      "network": {
        "description": "The network card its connection goes out on (Settings › Advanced › Network cards), \"(backup)\" after its name on the backup; null on the system's default network.",
        "type": [
          "string",
          "null"
        ]
      },
      "network_note": {
        "description": "Why it isn't on the card chosen, when it isn't: the card is gone, unplugged or has no address, or the protocol (SRT) can't be sent on a chosen card.",
        "type": [
          "string",
          "null"
        ]
      },
      "note": {
        "description": "What's happening now, in words (a reconnect in progress).",
        "type": [
          "string",
          "null"
        ]
      },
      "protocol": {
        "description": "How it's being sent: whip, veloq, rtmps, rtmp or srt.",
        "enum": [
          "whip",
          "veloq",
          "rtmps",
          "rtmp",
          "srt",
          null
        ],
        "title": "StreamProtocol",
        "type": [
          "string",
          "null"
        ]
      },
      "reconnect_attempt": {
        "description": "The reconnect attempt under way while reconnecting (0: none).",
        "type": [
          "integer",
          "null"
        ]
      },
      "reconnects": {
        "type": "integer"
      },
      "rtt_ms": {
        "description": "Round trip in milliseconds, while live.",
        "type": [
          "number",
          "null"
        ]
      },
      "seconds": {
        "description": "How long it's been live.",
        "type": "integer"
      },
      "send_kbps": {
        "description": "What the sender is pushing now in kbit/s, while live.",
        "type": [
          "number",
          "null"
        ]
      },
      "state": {
        "enum": [
          "offline",
          "delayed",
          "connecting",
          "live",
          "reconnecting",
          "stopping",
          "refused",
          "error"
        ],
        "title": "StreamStatus",
        "type": "string"
      },
      "stopping_in": {
        "description": "Stopping: seconds until the delay has played out and the stream ends.",
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "required": [
      "state"
    ],
    "title": "DestinationHealth",
    "type": "object"
  }
}

vcam.startStart virtual camera

Turns on the virtual camera so video-call apps can show what's on air.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • onbooleanalways

    On while the virtual camera is on.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

vcam.on bool

On while the virtual camera is on. From the vcam topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "vcam.start"
}

In the SDKs

C#
Task<VcamStartResult> VcamStartAsync(CancellationToken cancellationToken = default)
TypeScript
vcamStart(): Promise<VcamStartResult>
Python
async def vcam_start(self) -> VcamStartResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "on": {
        "description": "On while the virtual camera is on.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "on",
      "changed"
    ],
    "type": "object"
  }
}

vcam.stopStop virtual camera

Turns off the virtual camera.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • onbooleanalways

    On while the virtual camera is on.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

vcam.on bool

On while the virtual camera is on. From the vcam topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "vcam.stop"
}

In the SDKs

C#
Task<VcamStopResult> VcamStopAsync(CancellationToken cancellationToken = default)
TypeScript
vcamStop(): Promise<VcamStopResult>
Python
async def vcam_stop(self) -> VcamStopResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "on": {
        "description": "On while the virtual camera is on.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "on",
      "changed"
    ],
    "type": "object"
  }
}

vcam.toggleVirtual camera

Turns the virtual camera on, or off if it's on.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • onbooleanalways

    On while the virtual camera is on.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

vcam.on bool

On while the virtual camera is on. From the vcam topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "vcam.toggle"
}

In the SDKs

C#
Task<VcamToggleResult> VcamToggleAsync(CancellationToken cancellationToken = default)
TypeScript
vcamToggle(): Promise<VcamToggleResult>
Python
async def vcam_toggle(self) -> VcamToggleResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "on": {
        "description": "On while the virtual camera is on.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "on",
      "changed"
    ],
    "type": "object"
  }
}

vcam.sourceVirtual camera source

Chooses what the virtual camera sends: one scene (mode scene), drawn off air at the camera's size whatever is live (a webcam scene for a video call while the stream shows something else), or what's on air (mode on_air, the default; no scene needed). toggle sends the scene, or what's on air again when it's already sending it; with no scene, a camera sending a scene sends what's on air. Its cameras and captures keep capturing; videos in it show the picture they have (they play once on air). Video only: video-call apps take their sound from a microphone. Kept with the scene collection, whether the camera is on or off. If the scene is deleted, the camera sends what's on air again (one undo puts both back).

Keyscope: broadcast

Parameters

  • scenesceneoptional

    The scene to send (for scene and toggle). Give its id or name.

    Choices in scenes

  • modechoiceoptional

    Send the scene, send what's on air, or toggle.

    One of scene on_air toggle · Default "toggle"

Result

  • namestringalwayscan be null

    That scene's name.

  • scenestring (uuid)alwayscan be null

    The id of the scene it sends; null while it sends what's on air.

  • sourceVcamSource (string)always

    What the virtual camera sends now: on_air or scene.

    One of "on_air" "scene"

Live state

vcam.scene == scene bool

On while the virtual camera sends this scene. From the vcam topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "vcam.source"
}

In the SDKs

C#
Task<VcamSourceResult> VcamSourceAsync(CancellationToken cancellationToken = default)
Python
async def vcam_source(self, *, mode: VcamSourceMode | None = None, scene: str | None = None) -> VcamSourceResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "mode": {
        "default": "toggle",
        "description": "Send the scene, send what's on air, or toggle.",
        "enum": [
          "scene",
          "on_air",
          "toggle"
        ],
        "type": "string"
      },
      "scene": {
        "description": "The scene to send (for scene and toggle). Give its id or name.",
        "minLength": 1,
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "name": {
        "description": "That scene's name.",
        "type": [
          "string",
          "null"
        ]
      },
      "scene": {
        "description": "The id of the scene it sends; null while it sends what's on air.",
        "format": "uuid",
        "type": [
          "string",
          "null"
        ]
      },
      "source": {
        "description": "What the virtual camera sends now: on_air or scene.",
        "enum": [
          "on_air",
          "scene"
        ],
        "title": "VcamSource",
        "type": "string"
      }
    },
    "required": [
      "source",
      "scene",
      "name"
    ],
    "type": "object"
  }
}

ndi.startStart NDI® output

Sends the program as an NDI sender on the network (NDI® is a registered trademark of Vizrt NDI AB), with the settings in Settings › NDI® output. Needs the NDI runtime (NDI Tools) on this computer.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • onbooleanalways

    On while the program is sent over NDI®.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

ndi.on bool

On while the program is sent over NDI. From the ndi topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ndi.start"
}

In the SDKs

C#
Task<NdiStartResult> NdiStartAsync(CancellationToken cancellationToken = default)
TypeScript
ndiStart(): Promise<NdiStartResult>
Python
async def ndi_start(self) -> NdiStartResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "on": {
        "description": "On while the program is sent over NDI®.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "on",
      "changed"
    ],
    "type": "object"
  }
}

ndi.stopStop NDI® output

Stops sending the program over NDI. Sources set to send themselves keep going.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • onbooleanalways

    On while the program is sent over NDI®.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

ndi.on bool

On while the program is sent over NDI. From the ndi topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ndi.stop"
}

In the SDKs

C#
Task<NdiStopResult> NdiStopAsync(CancellationToken cancellationToken = default)
TypeScript
ndiStop(): Promise<NdiStopResult>
Python
async def ndi_stop(self) -> NdiStopResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "on": {
        "description": "On while the program is sent over NDI®.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "on",
      "changed"
    ],
    "type": "object"
  }
}

ndi.toggleNDI® output

Turns NDI output on, or off if it's on.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

  • changedbooleanalways

    False when it was already so: the press changed nothing.

  • onbooleanalways

    On while the program is sent over NDI®.

  • resultOutputReportoptional

    What the output reported, when it changed.

    Fields of result
    • okbooleanoptional
    • pathstringoptional

Live state

ndi.on bool

On while the program is sent over NDI. From the ndi topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ndi.toggle"
}

In the SDKs

C#
Task<NdiToggleResult> NdiToggleAsync(CancellationToken cancellationToken = default)
TypeScript
ndiToggle(): Promise<NdiToggleResult>
Python
async def ndi_toggle(self) -> NdiToggleResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "changed": {
        "description": "False when it was already so: the press changed nothing.",
        "type": "boolean"
      },
      "on": {
        "description": "On while the program is sent over NDI®.",
        "type": "boolean"
      },
      "result": {
        "additionalProperties": true,
        "description": "What the output reported, when it changed.",
        "properties": {
          "ok": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          }
        },
        "title": "OutputReport",
        "type": "object"
      }
    },
    "required": [
      "on",
      "changed"
    ],
    "type": "object"
  }
}

stats.showStats

Shows Studio's live numbers: frames rendered and late, and while live the bitrate, packet loss and round trip; while recording, frames dropped.

DisplayDialscope: control

Parameters

None. Leave params out.

Result

A StatsState. See its fields under Shapes.

Live state

the whole stats topic object

The stats topic, pushed every second. From the stats topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "stats.show"
}

In the SDKs

C#
Task<StatsState> StatsShowAsync(CancellationToken cancellationToken = default)
TypeScript
statsShow(): Promise<StatsState>
Python
async def stats_show(self) -> StatsState
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "fps": {
        "description": "The canvas's frame rate.",
        "type": [
          "number",
          "null"
        ]
      },
      "live": {
        "additionalProperties": false,
        "properties": {
          "bytes": {
            "type": [
              "integer",
              "null"
            ]
          },
          "kbps": {
            "type": [
              "number",
              "null"
            ]
          },
          "loss": {
            "type": [
              "number",
              "null"
            ]
          },
          "reconnects": {
            "type": "integer"
          },
          "rtt_ms": {
            "type": [
              "number",
              "null"
            ]
          }
        },
        "required": [
          "kbps",
          "loss",
          "rtt_ms",
          "reconnects",
          "bytes"
        ],
        "title": "LiveStats",
        "type": [
          "object",
          "null"
        ]
      },
      "output": {
        "additionalProperties": false,
        "properties": {
          "dropped": {
            "description": "Frames the stream's and the recording's encoders refused because they were behind.",
            "type": "integer"
          },
          "lagged": {
            "description": "Ticks the clock missed while an output ran; each was filled by repeating the previous picture or left out.",
            "type": [
              "integer",
              "null"
            ]
          },
          "rendered": {
            "description": "Program frames handed to the outputs (recording, stream, replay buffer, virtual camera): one per tick while any runs, at the canvas's frame rate when all is well.",
            "type": [
              "integer",
              "null"
            ]
          }
        },
        "required": [
          "rendered",
          "lagged",
          "dropped"
        ],
        "title": "OutputStats",
        "type": "object"
      },
      "preview": {
        "additionalProperties": false,
        "properties": {
          "idle": {
            "description": "Ticks with nothing new for the preview to draw.",
            "type": [
              "integer",
              "null"
            ]
          },
          "rendered": {
            "description": "Frames drawn for the preview. None while the preview is hidden or nothing on it changes, whatever goes out: not a measure of the stream.",
            "type": [
              "integer",
              "null"
            ]
          }
        },
        "required": [
          "rendered",
          "idle"
        ],
        "title": "PreviewStats",
        "type": "object"
      },
      "record": {
        "additionalProperties": false,
        "properties": {
          "dropped": {
            "type": [
              "integer",
              "null"
            ]
          },
          "frames": {
            "type": [
              "integer",
              "null"
            ]
          }
        },
        "required": [
          "frames",
          "dropped"
        ],
        "title": "RecordStats",
        "type": [
          "object",
          "null"
        ]
      },
      "render": {
        "additionalProperties": false,
        "description": "Deprecated: use preview and output. The preview's paints (rendered, idle) and every tick the clock missed (lagged); kept for older clients for one release.",
        "properties": {
          "idle": {
            "type": "integer"
          },
          "lagged": {
            "description": "Ticks the clock missed, whether or not anything was going out.",
            "type": "integer"
          },
          "rendered": {
            "description": "Frames drawn for the preview (see preview.rendered).",
            "type": "integer"
          }
        },
        "required": [],
        "title": "RenderStats",
        "type": [
          "object",
          "null"
        ]
      }
    },
    "required": [
      "fps",
      "preview",
      "output",
      "render",
      "live",
      "record"
    ],
    "title": "StatsState",
    "type": "object"
  }
}

stream.viewersViewers

Shows how many are watching on each platform that says, while live.

Displayscope: control

Parameters

None. Leave params out.

Result

map of id → integer

Viewers by platform, while live; empty while offline.

Live state

stream.viewers object

Viewers by platform id ({"velora": 12}); empty while offline. From the stream topic. How to read it.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "stream.viewers"
}

In the SDKs

C#
Task<IReadOnlyDictionary<string, long>> StreamViewersAsync(CancellationToken cancellationToken = default)
TypeScript
streamViewers(): Promise<Record<string, number>>
Python
async def stream_viewers(self) -> dict[str, int]
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": {
      "type": "integer"
    },
    "description": "Viewers by platform, while live; empty while offline.",
    "type": "object"
  }
}

raid.targetsWho's live to raid

Lists the live channels you can raid on a platform, most watched first: on Velora every live channel, on Twitch the live channels in your category; a query searches live channels by name. Each one's linked lists the other channels its owner linked as theirs (Velora: a connected Twitch account shared for raid matching), for raiding them everywhere at once. With also_live, each one's also_live is that person live on your other connected platforms: linked (explicit link), likely (near-identical name, same game and a strongly matching title) or possible (something matches, not all of it), with a confidence and the reasons; only linked and likely are prechecked.

Keyscope: broadcast

Parameters

  • platformchoiceoptional

    Where to raid; Velora when signed in, else Twitch.

    One of velora twitch

  • querytextoptional

    Search live channels by name (and, on Velora, category).

    Up to 100 characters

  • also_livebooloptional

    Also look for each one on your other connected platforms (each entry's also_live): an explicit link first, else a match by name, game, title and picture, with its confidence and reasons. Slower: it asks those platforms.

Result

  • platformstringalways

    Where they're live.

  • targetsarray of RaidTargetalways

    Who's live, most watched first.

    Fields of targets
    • also_livearray of RaidAlsoLiveoptional

      With raid.targets' also_live: this person live on your other connected platforms, at most one per platform (left out otherwise).

    • avatarstringalways

      An avatar picture (https), or empty.

    • categorystringalways

      What they're streaming, or empty.

    • display_namestringalways

      The name as shown.

    • idstringalways

      The platform's id for the channel.

    • linkedarray of RaidLinkedChannelalways

      Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.

    • loginstringalways

      The name the platform raids by (raid.start's target).

    • titlestringalways

      The stream's title.

    • viewersintegeralways

      Watching now.

Live state

This action has no live state.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "raid.targets"
}

In the SDKs

C#
Task<RaidTargetsResult> RaidTargetsAsync(CancellationToken cancellationToken = default)
Python
async def raid_targets(self, *, also_live: bool | None = None, platform: RaidTargetsPlatform | None = None, query: str | None = None) -> RaidTargetsResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "also_live": {
        "description": "Also look for each one on your other connected platforms (each entry's also_live): an explicit link first, else a match by name, game, title and picture, with its confidence and reasons. Slower: it asks those platforms.",
        "type": "boolean"
      },
      "platform": {
        "description": "Where to raid; Velora when signed in, else Twitch.",
        "enum": [
          "velora",
          "twitch"
        ],
        "type": "string"
      },
      "query": {
        "description": "Search live channels by name (and, on Velora, category).",
        "maxLength": 100,
        "type": "string"
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "platform": {
        "description": "Where they're live.",
        "type": "string"
      },
      "targets": {
        "description": "Who's live, most watched first.",
        "items": {
          "additionalProperties": false,
          "properties": {
            "also_live": {
              "description": "With raid.targets' also_live: this person live on your other connected platforms, at most one per platform (left out otherwise).",
              "items": {
                "additionalProperties": false,
                "properties": {
                  "confidence": {
                    "description": "0 to 1 (1 for a link).",
                    "type": "number"
                  },
                  "match": {
                    "description": "linked: an explicit link (a connected account its owner shared). likely: no link, but a near-identical name, the same game and a strongly matching title. possible: something matches, not all of it; confirm it's them.",
                    "enum": [
                      "linked",
                      "likely",
                      "possible"
                    ],
                    "title": "RaidMatch",
                    "type": "string"
                  },
                  "platform": {
                    "description": "Where they're also live.",
                    "type": "string"
                  },
                  "platform_name": {
                    "description": "The platform's name as shown.",
                    "type": "string"
                  },
                  "prechecked": {
                    "description": "Studio offers it checked: linked or likely only, never a weaker match.",
                    "type": "boolean"
                  },
                  "reasons": {
                    "description": "Why, each in a few words: \"Same name\", \"Same game\", \"The titles match\", \"But a different game\".",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  },
                  "summary": {
                    "description": "The reasons as one sentence: \"Same name and same game, and the titles match\".",
                    "type": "string"
                  },
                  "target": {
                    "additionalProperties": false,
                    "description": "Their channel there (raid.start's targets take it as is).",
                    "properties": {
                      "avatar": {
                        "description": "An avatar picture (https), or empty.",
                        "type": "string"
                      },
                      "category": {
                        "description": "What they're streaming, or empty.",
                        "type": "string"
                      },
                      "display_name": {
                        "description": "The name as shown.",
                        "type": "string"
                      },
                      "id": {
                        "description": "The platform's id for the channel.",
                        "type": "string"
                      },
                      "linked": {
                        "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
                        "items": {
                          "additionalProperties": false,
                          "properties": {
                            "display_name": {
                              "description": "Its name as shown.",
                              "type": "string"
                            },
                            "id": {
                              "description": "That platform's id for the channel (matched on this, not the name).",
                              "type": "string"
                            },
                            "login": {
                              "description": "Its name there.",
                              "type": "string"
                            },
                            "platform": {
                              "description": "Where it is: twitch or kick.",
                              "type": "string"
                            }
                          },
                          "required": [
                            "platform",
                            "id",
                            "login",
                            "display_name"
                          ],
                          "title": "RaidLinkedChannel",
                          "type": "object"
                        },
                        "type": "array"
                      },
                      "login": {
                        "description": "The name the platform raids by (raid.start's target).",
                        "type": "string"
                      },
                      "title": {
                        "description": "The stream's title.",
                        "type": "string"
                      },
                      "viewers": {
                        "description": "Watching now.",
                        "type": "integer"
                      }
                    },
                    "required": [
                      "id",
                      "login",
                      "display_name",
                      "avatar",
                      "category",
                      "title",
                      "viewers",
                      "linked"
                    ],
                    "title": "RaidAlsoLiveTarget",
                    "type": "object"
                  }
                },
                "required": [
                  "platform",
                  "platform_name",
                  "target",
                  "match",
                  "confidence",
                  "reasons",
                  "summary",
                  "prechecked"
                ],
                "title": "RaidAlsoLive",
                "type": "object"
              },
              "type": "array"
            },
            "avatar": {
              "description": "An avatar picture (https), or empty.",
              "type": "string"
            },
            "category": {
              "description": "What they're streaming, or empty.",
              "type": "string"
            },
            "display_name": {
              "description": "The name as shown.",
              "type": "string"
            },
            "id": {
              "description": "The platform's id for the channel.",
              "type": "string"
            },
            "linked": {
              "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
              "items": {
                "additionalProperties": false,
                "properties": {
                  "display_name": {
                    "description": "Its name as shown.",
                    "type": "string"
                  },
                  "id": {
                    "description": "That platform's id for the channel (matched on this, not the name).",
                    "type": "string"
                  },
                  "login": {
                    "description": "Its name there.",
                    "type": "string"
                  },
                  "platform": {
                    "description": "Where it is: twitch or kick.",
                    "type": "string"
                  }
                },
                "required": [
                  "platform",
                  "id",
                  "login",
                  "display_name"
                ],
                "title": "RaidLinkedChannel",
                "type": "object"
              },
              "type": "array"
            },
            "login": {
              "description": "The name the platform raids by (raid.start's target).",
              "type": "string"
            },
            "title": {
              "description": "The stream's title.",
              "type": "string"
            },
            "viewers": {
              "description": "Watching now.",
              "type": "integer"
            }
          },
          "required": [
            "id",
            "login",
            "display_name",
            "avatar",
            "category",
            "title",
            "viewers",
            "linked"
          ],
          "title": "RaidTarget",
          "type": "object"
        },
        "type": "array"
      }
    },
    "required": [
      "platform",
      "targets"
    ],
    "type": "object"
  }
}

raid.startRaid

Starts a raid on a live channel, or on the same person on several platforms at once (targets). A countdown runs (viewers see the raid card and its message right away), then the raid goes out: on Velora when the countdown ends, on Twitch after its own 90-second countdown or Raid Now on twitch.tv. With Twitch in the raid, Velora takes Twitch's countdown so both go out together. Each platform confirms or fails on its own (the result's raids). The stream stays up; end it once every platform has answered.

Keyscope: broadcast

Parameters

  • targettextoptional

    The channel's name on that platform (or use targets).

    Up to 64 characters

  • targetsjsonoptional

    Several platforms at once, one raid each with one countdown: [{"platform":"velora","target":"name"},{"platform":"twitch","target":"name"}] (a target may also be a raid.targets entry). In place of target and platform.

  • platformchoiceoptional

    Where to raid; Velora when signed in, else Twitch.

    One of velora twitch

  • messagetextoptional

    Velora only: the raid message viewers see; your saved raid message when left out.

    Up to 500 characters

  • countdownintegeroptional

    Velora only: seconds before it goes out; your saved countdown when left out.

    20 to 120 s

Result

A RaidStatus. See its fields under Shapes.

Live state

This action has no live state.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "raid.start"
}

In the SDKs

C#
Task<RaidStatus> RaidStartAsync(CancellationToken cancellationToken = default)
Python
async def raid_start(self, *, countdown: int | None = None, message: str | None = None, platform: RaidStartPlatform | None = None, target: str | None = None, targets: Any | None = None) -> RaidStatus
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "countdown": {
        "description": "Velora only: seconds before it goes out; your saved countdown when left out.",
        "maximum": 120,
        "minimum": 20,
        "type": "integer"
      },
      "message": {
        "description": "Velora only: the raid message viewers see; your saved raid message when left out.",
        "maxLength": 500,
        "type": "string"
      },
      "platform": {
        "description": "Where to raid; Velora when signed in, else Twitch.",
        "enum": [
          "velora",
          "twitch"
        ],
        "type": "string"
      },
      "target": {
        "description": "The channel's name on that platform (or use targets).",
        "maxLength": 64,
        "type": "string"
      },
      "targets": {
        "description": "Several platforms at once, one raid each with one countdown: [{\"platform\":\"velora\",\"target\":\"name\"},{\"platform\":\"twitch\",\"target\":\"name\"}] (a target may also be a raid.targets entry). In place of target and platform."
      }
    },
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "active": {
        "description": "A raid is in progress (or just finished and not yet dismissed).",
        "type": "boolean"
      },
      "already": {
        "description": "Sent because the platform says the raid already went out (the first platform's); note says so.",
        "type": "boolean"
      },
      "ends_at_ms": {
        "description": "When the countdown ends (epoch ms), while counting down.",
        "type": [
          "integer",
          "null"
        ]
      },
      "generation": {
        "description": "Changes whenever the raid does.",
        "type": "integer"
      },
      "message": {
        "description": "The raid card's message as you see it (Velora; subscriber message first).",
        "type": "string"
      },
      "message_everyone": {
        "description": "The card's message for viewers who aren't subscribed, when it differs.",
        "type": "string"
      },
      "note": {
        "description": "Why it was cancelled or failed, or something to know (the first platform's).",
        "type": [
          "string",
          "null"
        ]
      },
      "phase": {
        "description": "The whole raid: counting_down while any platform is; then sent (every platform's went out), partial (some did), cancelled or failed.",
        "enum": [
          "counting_down",
          "sent",
          "partial",
          "cancelled",
          "failed"
        ],
        "title": "RaidGroupPhase",
        "type": "string"
      },
      "platform": {
        "description": "Where it's raiding.",
        "type": "string"
      },
      "platform_name": {
        "description": "The platform's name as shown.",
        "type": "string"
      },
      "raids": {
        "description": "Each platform's raid, one per platform, sharing one countdown. The top-level platform, target and note are the first one's.",
        "items": {
          "additionalProperties": false,
          "properties": {
            "already": {
              "description": "Sent because the platform says this raid already went out (a raid to the same channel moments before, from the website or another app); note says so.",
              "type": "boolean"
            },
            "ends_at_ms": {
              "description": "When its countdown ends (epoch ms), while counting down.",
              "type": [
                "integer",
                "null"
              ]
            },
            "message": {
              "description": "The raid card's message as you see it (Velora; subscriber message first).",
              "type": "string"
            },
            "message_everyone": {
              "description": "The card's message for viewers who aren't subscribed, when it differs.",
              "type": "string"
            },
            "note": {
              "description": "Why it was cancelled or failed, or something to know.",
              "type": [
                "string",
                "null"
              ]
            },
            "phase": {
              "description": "counting_down, sent, cancelled or failed.",
              "enum": [
                "counting_down",
                "sent",
                "cancelled",
                "failed"
              ],
              "title": "RaidPhase",
              "type": "string"
            },
            "platform": {
              "description": "Where it's raiding.",
              "type": "string"
            },
            "platform_name": {
              "description": "The platform's name as shown.",
              "type": "string"
            },
            "seconds_left": {
              "description": "Seconds until it goes out, while counting down.",
              "type": [
                "integer",
                "null"
              ]
            },
            "send_now": {
              "description": "\"Raid now\" can send it early.",
              "type": "boolean"
            },
            "target": {
              "additionalProperties": false,
              "description": "Who it's raiding there.",
              "properties": {
                "also_live": {
                  "description": "With raid.targets' also_live: this person live on your other connected platforms, at most one per platform (left out otherwise).",
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "confidence": {
                        "description": "0 to 1 (1 for a link).",
                        "type": "number"
                      },
                      "match": {
                        "description": "linked: an explicit link (a connected account its owner shared). likely: no link, but a near-identical name, the same game and a strongly matching title. possible: something matches, not all of it; confirm it's them.",
                        "enum": [
                          "linked",
                          "likely",
                          "possible"
                        ],
                        "title": "RaidMatch",
                        "type": "string"
                      },
                      "platform": {
                        "description": "Where they're also live.",
                        "type": "string"
                      },
                      "platform_name": {
                        "description": "The platform's name as shown.",
                        "type": "string"
                      },
                      "prechecked": {
                        "description": "Studio offers it checked: linked or likely only, never a weaker match.",
                        "type": "boolean"
                      },
                      "reasons": {
                        "description": "Why, each in a few words: \"Same name\", \"Same game\", \"The titles match\", \"But a different game\".",
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "summary": {
                        "description": "The reasons as one sentence: \"Same name and same game, and the titles match\".",
                        "type": "string"
                      },
                      "target": {
                        "additionalProperties": false,
                        "description": "Their channel there (raid.start's targets take it as is).",
                        "properties": {
                          "avatar": {
                            "description": "An avatar picture (https), or empty.",
                            "type": "string"
                          },
                          "category": {
                            "description": "What they're streaming, or empty.",
                            "type": "string"
                          },
                          "display_name": {
                            "description": "The name as shown.",
                            "type": "string"
                          },
                          "id": {
                            "description": "The platform's id for the channel.",
                            "type": "string"
                          },
                          "linked": {
                            "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
                            "items": {
                              "additionalProperties": false,
                              "properties": {
                                "display_name": {
                                  "description": "Its name as shown.",
                                  "type": "string"
                                },
                                "id": {
                                  "description": "That platform's id for the channel (matched on this, not the name).",
                                  "type": "string"
                                },
                                "login": {
                                  "description": "Its name there.",
                                  "type": "string"
                                },
                                "platform": {
                                  "description": "Where it is: twitch or kick.",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "platform",
                                "id",
                                "login",
                                "display_name"
                              ],
                              "title": "RaidLinkedChannel",
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "login": {
                            "description": "The name the platform raids by (raid.start's target).",
                            "type": "string"
                          },
                          "title": {
                            "description": "The stream's title.",
                            "type": "string"
                          },
                          "viewers": {
                            "description": "Watching now.",
                            "type": "integer"
                          }
                        },
                        "required": [
                          "id",
                          "login",
                          "display_name",
                          "avatar",
                          "category",
                          "title",
                          "viewers",
                          "linked"
                        ],
                        "title": "RaidAlsoLiveTarget",
                        "type": "object"
                      }
                    },
                    "required": [
                      "platform",
                      "platform_name",
                      "target",
                      "match",
                      "confidence",
                      "reasons",
                      "summary",
                      "prechecked"
                    ],
                    "title": "RaidAlsoLive",
                    "type": "object"
                  },
                  "type": "array"
                },
                "avatar": {
                  "description": "An avatar picture (https), or empty.",
                  "type": "string"
                },
                "category": {
                  "description": "What they're streaming, or empty.",
                  "type": "string"
                },
                "display_name": {
                  "description": "The name as shown.",
                  "type": "string"
                },
                "id": {
                  "description": "The platform's id for the channel.",
                  "type": "string"
                },
                "linked": {
                  "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "display_name": {
                        "description": "Its name as shown.",
                        "type": "string"
                      },
                      "id": {
                        "description": "That platform's id for the channel (matched on this, not the name).",
                        "type": "string"
                      },
                      "login": {
                        "description": "Its name there.",
                        "type": "string"
                      },
                      "platform": {
                        "description": "Where it is: twitch or kick.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "platform",
                      "id",
                      "login",
                      "display_name"
                    ],
                    "title": "RaidLinkedChannel",
                    "type": "object"
                  },
                  "type": "array"
                },
                "login": {
                  "description": "The name the platform raids by (raid.start's target).",
                  "type": "string"
                },
                "title": {
                  "description": "The stream's title.",
                  "type": "string"
                },
                "viewers": {
                  "description": "Watching now.",
                  "type": "integer"
                }
              },
              "required": [
                "id",
                "login",
                "display_name",
                "avatar",
                "category",
                "title",
                "viewers",
                "linked"
              ],
              "title": "RaidTarget",
              "type": "object"
            },
            "via_chat": {
              "description": "Started with Velora's /raid chat command (an older Velora).",
              "type": "boolean"
            },
            "viewers": {
              "description": "How many went along, once sent.",
              "type": [
                "integer",
                "null"
              ]
            }
          },
          "required": [
            "platform",
            "platform_name",
            "target",
            "phase",
            "send_now",
            "via_chat"
          ],
          "title": "RaidLegStatus",
          "type": "object"
        },
        "type": "array"
      },
      "seconds_left": {
        "description": "Seconds until it goes out (the last platform's), while counting down.",
        "type": [
          "integer",
          "null"
        ]
      },
      "send_now": {
        "description": "\"Raid now\" can send it early (on at least one platform).",
        "type": "boolean"
      },
      "target": {
        "additionalProperties": false,
        "description": "Who it's raiding.",
        "properties": {
          "also_live": {
            "description": "With raid.targets' also_live: this person live on your other connected platforms, at most one per platform (left out otherwise).",
            "items": {
              "additionalProperties": false,
              "properties": {
                "confidence": {
                  "description": "0 to 1 (1 for a link).",
                  "type": "number"
                },
                "match": {
                  "description": "linked: an explicit link (a connected account its owner shared). likely: no link, but a near-identical name, the same game and a strongly matching title. possible: something matches, not all of it; confirm it's them.",
                  "enum": [
                    "linked",
                    "likely",
                    "possible"
                  ],
                  "title": "RaidMatch",
                  "type": "string"
                },
                "platform": {
                  "description": "Where they're also live.",
                  "type": "string"
                },
                "platform_name": {
                  "description": "The platform's name as shown.",
                  "type": "string"
                },
                "prechecked": {
                  "description": "Studio offers it checked: linked or likely only, never a weaker match.",
                  "type": "boolean"
                },
                "reasons": {
                  "description": "Why, each in a few words: \"Same name\", \"Same game\", \"The titles match\", \"But a different game\".",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "summary": {
                  "description": "The reasons as one sentence: \"Same name and same game, and the titles match\".",
                  "type": "string"
                },
                "target": {
                  "additionalProperties": false,
                  "description": "Their channel there (raid.start's targets take it as is).",
                  "properties": {
                    "avatar": {
                      "description": "An avatar picture (https), or empty.",
                      "type": "string"
                    },
                    "category": {
                      "description": "What they're streaming, or empty.",
                      "type": "string"
                    },
                    "display_name": {
                      "description": "The name as shown.",
                      "type": "string"
                    },
                    "id": {
                      "description": "The platform's id for the channel.",
                      "type": "string"
                    },
                    "linked": {
                      "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
                      "items": {
                        "additionalProperties": false,
                        "properties": {
                          "display_name": {
                            "description": "Its name as shown.",
                            "type": "string"
                          },
                          "id": {
                            "description": "That platform's id for the channel (matched on this, not the name).",
                            "type": "string"
                          },
                          "login": {
                            "description": "Its name there.",
                            "type": "string"
                          },
                          "platform": {
                            "description": "Where it is: twitch or kick.",
                            "type": "string"
                          }
                        },
                        "required": [
                          "platform",
                          "id",
                          "login",
                          "display_name"
                        ],
                        "title": "RaidLinkedChannel",
                        "type": "object"
                      },
                      "type": "array"
                    },
                    "login": {
                      "description": "The name the platform raids by (raid.start's target).",
                      "type": "string"
                    },
                    "title": {
                      "description": "The stream's title.",
                      "type": "string"
                    },
                    "viewers": {
                      "description": "Watching now.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "id",
                    "login",
                    "display_name",
                    "avatar",
                    "category",
                    "title",
                    "viewers",
                    "linked"
                  ],
                  "title": "RaidAlsoLiveTarget",
                  "type": "object"
                }
              },
              "required": [
                "platform",
                "platform_name",
                "target",
                "match",
                "confidence",
                "reasons",
                "summary",
                "prechecked"
              ],
              "title": "RaidAlsoLive",
              "type": "object"
            },
            "type": "array"
          },
          "avatar": {
            "description": "An avatar picture (https), or empty.",
            "type": "string"
          },
          "category": {
            "description": "What they're streaming, or empty.",
            "type": "string"
          },
          "display_name": {
            "description": "The name as shown.",
            "type": "string"
          },
          "id": {
            "description": "The platform's id for the channel.",
            "type": "string"
          },
          "linked": {
            "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
            "items": {
              "additionalProperties": false,
              "properties": {
                "display_name": {
                  "description": "Its name as shown.",
                  "type": "string"
                },
                "id": {
                  "description": "That platform's id for the channel (matched on this, not the name).",
                  "type": "string"
                },
                "login": {
                  "description": "Its name there.",
                  "type": "string"
                },
                "platform": {
                  "description": "Where it is: twitch or kick.",
                  "type": "string"
                }
              },
              "required": [
                "platform",
                "id",
                "login",
                "display_name"
              ],
              "title": "RaidLinkedChannel",
              "type": "object"
            },
            "type": "array"
          },
          "login": {
            "description": "The name the platform raids by (raid.start's target).",
            "type": "string"
          },
          "title": {
            "description": "The stream's title.",
            "type": "string"
          },
          "viewers": {
            "description": "Watching now.",
            "type": "integer"
          }
        },
        "required": [
          "id",
          "login",
          "display_name",
          "avatar",
          "category",
          "title",
          "viewers",
          "linked"
        ],
        "title": "RaidTarget",
        "type": "object"
      },
      "via_chat": {
        "description": "Started with Velora's /raid chat command (an older Velora).",
        "type": "boolean"
      },
      "viewers": {
        "description": "How many went along, once sent (all platforms together).",
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "required": [
      "active",
      "generation",
      "raids"
    ],
    "title": "RaidStatus",
    "type": "object"
  }
}

raid.cancelCancel raid

Calls off the raid counting down, on every platform it's counting down on.

Keyscope: broadcast

Parameters

None. Leave params out.

Result

A RaidStatus. See its fields under Shapes.

Live state

This action has no live state.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "raid.cancel"
}

In the SDKs

C#
Task<RaidStatus> RaidCancelAsync(CancellationToken cancellationToken = default)
TypeScript
raidCancel(): Promise<RaidStatus>
Python
async def raid_cancel(self) -> RaidStatus
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {},
    "required": [],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "active": {
        "description": "A raid is in progress (or just finished and not yet dismissed).",
        "type": "boolean"
      },
      "already": {
        "description": "Sent because the platform says the raid already went out (the first platform's); note says so.",
        "type": "boolean"
      },
      "ends_at_ms": {
        "description": "When the countdown ends (epoch ms), while counting down.",
        "type": [
          "integer",
          "null"
        ]
      },
      "generation": {
        "description": "Changes whenever the raid does.",
        "type": "integer"
      },
      "message": {
        "description": "The raid card's message as you see it (Velora; subscriber message first).",
        "type": "string"
      },
      "message_everyone": {
        "description": "The card's message for viewers who aren't subscribed, when it differs.",
        "type": "string"
      },
      "note": {
        "description": "Why it was cancelled or failed, or something to know (the first platform's).",
        "type": [
          "string",
          "null"
        ]
      },
      "phase": {
        "description": "The whole raid: counting_down while any platform is; then sent (every platform's went out), partial (some did), cancelled or failed.",
        "enum": [
          "counting_down",
          "sent",
          "partial",
          "cancelled",
          "failed"
        ],
        "title": "RaidGroupPhase",
        "type": "string"
      },
      "platform": {
        "description": "Where it's raiding.",
        "type": "string"
      },
      "platform_name": {
        "description": "The platform's name as shown.",
        "type": "string"
      },
      "raids": {
        "description": "Each platform's raid, one per platform, sharing one countdown. The top-level platform, target and note are the first one's.",
        "items": {
          "additionalProperties": false,
          "properties": {
            "already": {
              "description": "Sent because the platform says this raid already went out (a raid to the same channel moments before, from the website or another app); note says so.",
              "type": "boolean"
            },
            "ends_at_ms": {
              "description": "When its countdown ends (epoch ms), while counting down.",
              "type": [
                "integer",
                "null"
              ]
            },
            "message": {
              "description": "The raid card's message as you see it (Velora; subscriber message first).",
              "type": "string"
            },
            "message_everyone": {
              "description": "The card's message for viewers who aren't subscribed, when it differs.",
              "type": "string"
            },
            "note": {
              "description": "Why it was cancelled or failed, or something to know.",
              "type": [
                "string",
                "null"
              ]
            },
            "phase": {
              "description": "counting_down, sent, cancelled or failed.",
              "enum": [
                "counting_down",
                "sent",
                "cancelled",
                "failed"
              ],
              "title": "RaidPhase",
              "type": "string"
            },
            "platform": {
              "description": "Where it's raiding.",
              "type": "string"
            },
            "platform_name": {
              "description": "The platform's name as shown.",
              "type": "string"
            },
            "seconds_left": {
              "description": "Seconds until it goes out, while counting down.",
              "type": [
                "integer",
                "null"
              ]
            },
            "send_now": {
              "description": "\"Raid now\" can send it early.",
              "type": "boolean"
            },
            "target": {
              "additionalProperties": false,
              "description": "Who it's raiding there.",
              "properties": {
                "also_live": {
                  "description": "With raid.targets' also_live: this person live on your other connected platforms, at most one per platform (left out otherwise).",
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "confidence": {
                        "description": "0 to 1 (1 for a link).",
                        "type": "number"
                      },
                      "match": {
                        "description": "linked: an explicit link (a connected account its owner shared). likely: no link, but a near-identical name, the same game and a strongly matching title. possible: something matches, not all of it; confirm it's them.",
                        "enum": [
                          "linked",
                          "likely",
                          "possible"
                        ],
                        "title": "RaidMatch",
                        "type": "string"
                      },
                      "platform": {
                        "description": "Where they're also live.",
                        "type": "string"
                      },
                      "platform_name": {
                        "description": "The platform's name as shown.",
                        "type": "string"
                      },
                      "prechecked": {
                        "description": "Studio offers it checked: linked or likely only, never a weaker match.",
                        "type": "boolean"
                      },
                      "reasons": {
                        "description": "Why, each in a few words: \"Same name\", \"Same game\", \"The titles match\", \"But a different game\".",
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "summary": {
                        "description": "The reasons as one sentence: \"Same name and same game, and the titles match\".",
                        "type": "string"
                      },
                      "target": {
                        "additionalProperties": false,
                        "description": "Their channel there (raid.start's targets take it as is).",
                        "properties": {
                          "avatar": {
                            "description": "An avatar picture (https), or empty.",
                            "type": "string"
                          },
                          "category": {
                            "description": "What they're streaming, or empty.",
                            "type": "string"
                          },
                          "display_name": {
                            "description": "The name as shown.",
                            "type": "string"
                          },
                          "id": {
                            "description": "The platform's id for the channel.",
                            "type": "string"
                          },
                          "linked": {
                            "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
                            "items": {
                              "additionalProperties": false,
                              "properties": {
                                "display_name": {
                                  "description": "Its name as shown.",
                                  "type": "string"
                                },
                                "id": {
                                  "description": "That platform's id for the channel (matched on this, not the name).",
                                  "type": "string"
                                },
                                "login": {
                                  "description": "Its name there.",
                                  "type": "string"
                                },
                                "platform": {
                                  "description": "Where it is: twitch or kick.",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "platform",
                                "id",
                                "login",
                                "display_name"
                              ],
                              "title": "RaidLinkedChannel",
                              "type": "object"
                            },
                            "type": "array"
                          },
                          "login": {
                            "description": "The name the platform raids by (raid.start's target).",
                            "type": "string"
                          },
                          "title": {
                            "description": "The stream's title.",
                            "type": "string"
                          },
                          "viewers": {
                            "description": "Watching now.",
                            "type": "integer"
                          }
                        },
                        "required": [
                          "id",
                          "login",
                          "display_name",
                          "avatar",
                          "category",
                          "title",
                          "viewers",
                          "linked"
                        ],
                        "title": "RaidAlsoLiveTarget",
                        "type": "object"
                      }
                    },
                    "required": [
                      "platform",
                      "platform_name",
                      "target",
                      "match",
                      "confidence",
                      "reasons",
                      "summary",
                      "prechecked"
                    ],
                    "title": "RaidAlsoLive",
                    "type": "object"
                  },
                  "type": "array"
                },
                "avatar": {
                  "description": "An avatar picture (https), or empty.",
                  "type": "string"
                },
                "category": {
                  "description": "What they're streaming, or empty.",
                  "type": "string"
                },
                "display_name": {
                  "description": "The name as shown.",
                  "type": "string"
                },
                "id": {
                  "description": "The platform's id for the channel.",
                  "type": "string"
                },
                "linked": {
                  "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "display_name": {
                        "description": "Its name as shown.",
                        "type": "string"
                      },
                      "id": {
                        "description": "That platform's id for the channel (matched on this, not the name).",
                        "type": "string"
                      },
                      "login": {
                        "description": "Its name there.",
                        "type": "string"
                      },
                      "platform": {
                        "description": "Where it is: twitch or kick.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "platform",
                      "id",
                      "login",
                      "display_name"
                    ],
                    "title": "RaidLinkedChannel",
                    "type": "object"
                  },
                  "type": "array"
                },
                "login": {
                  "description": "The name the platform raids by (raid.start's target).",
                  "type": "string"
                },
                "title": {
                  "description": "The stream's title.",
                  "type": "string"
                },
                "viewers": {
                  "description": "Watching now.",
                  "type": "integer"
                }
              },
              "required": [
                "id",
                "login",
                "display_name",
                "avatar",
                "category",
                "title",
                "viewers",
                "linked"
              ],
              "title": "RaidTarget",
              "type": "object"
            },
            "via_chat": {
              "description": "Started with Velora's /raid chat command (an older Velora).",
              "type": "boolean"
            },
            "viewers": {
              "description": "How many went along, once sent.",
              "type": [
                "integer",
                "null"
              ]
            }
          },
          "required": [
            "platform",
            "platform_name",
            "target",
            "phase",
            "send_now",
            "via_chat"
          ],
          "title": "RaidLegStatus",
          "type": "object"
        },
        "type": "array"
      },
      "seconds_left": {
        "description": "Seconds until it goes out (the last platform's), while counting down.",
        "type": [
          "integer",
          "null"
        ]
      },
      "send_now": {
        "description": "\"Raid now\" can send it early (on at least one platform).",
        "type": "boolean"
      },
      "target": {
        "additionalProperties": false,
        "description": "Who it's raiding.",
        "properties": {
          "also_live": {
            "description": "With raid.targets' also_live: this person live on your other connected platforms, at most one per platform (left out otherwise).",
            "items": {
              "additionalProperties": false,
              "properties": {
                "confidence": {
                  "description": "0 to 1 (1 for a link).",
                  "type": "number"
                },
                "match": {
                  "description": "linked: an explicit link (a connected account its owner shared). likely: no link, but a near-identical name, the same game and a strongly matching title. possible: something matches, not all of it; confirm it's them.",
                  "enum": [
                    "linked",
                    "likely",
                    "possible"
                  ],
                  "title": "RaidMatch",
                  "type": "string"
                },
                "platform": {
                  "description": "Where they're also live.",
                  "type": "string"
                },
                "platform_name": {
                  "description": "The platform's name as shown.",
                  "type": "string"
                },
                "prechecked": {
                  "description": "Studio offers it checked: linked or likely only, never a weaker match.",
                  "type": "boolean"
                },
                "reasons": {
                  "description": "Why, each in a few words: \"Same name\", \"Same game\", \"The titles match\", \"But a different game\".",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "summary": {
                  "description": "The reasons as one sentence: \"Same name and same game, and the titles match\".",
                  "type": "string"
                },
                "target": {
                  "additionalProperties": false,
                  "description": "Their channel there (raid.start's targets take it as is).",
                  "properties": {
                    "avatar": {
                      "description": "An avatar picture (https), or empty.",
                      "type": "string"
                    },
                    "category": {
                      "description": "What they're streaming, or empty.",
                      "type": "string"
                    },
                    "display_name": {
                      "description": "The name as shown.",
                      "type": "string"
                    },
                    "id": {
                      "description": "The platform's id for the channel.",
                      "type": "string"
                    },
                    "linked": {
                      "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
                      "items": {
                        "additionalProperties": false,
                        "properties": {
                          "display_name": {
                            "description": "Its name as shown.",
                            "type": "string"
                          },
                          "id": {
                            "description": "That platform's id for the channel (matched on this, not the name).",
                            "type": "string"
                          },
                          "login": {
                            "description": "Its name there.",
                            "type": "string"
                          },
                          "platform": {
                            "description": "Where it is: twitch or kick.",
                            "type": "string"
                          }
                        },
                        "required": [
                          "platform",
                          "id",
                          "login",
                          "display_name"
                        ],
                        "title": "RaidLinkedChannel",
                        "type": "object"
                      },
                      "type": "array"
                    },
                    "login": {
                      "description": "The name the platform raids by (raid.start's target).",
                      "type": "string"
                    },
                    "title": {
                      "description": "The stream's title.",
                      "type": "string"
                    },
                    "viewers": {
                      "description": "Watching now.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "id",
                    "login",
                    "display_name",
                    "avatar",
                    "category",
                    "title",
                    "viewers",
                    "linked"
                  ],
                  "title": "RaidAlsoLiveTarget",
                  "type": "object"
                }
              },
              "required": [
                "platform",
                "platform_name",
                "target",
                "match",
                "confidence",
                "reasons",
                "summary",
                "prechecked"
              ],
              "title": "RaidAlsoLive",
              "type": "object"
            },
            "type": "array"
          },
          "avatar": {
            "description": "An avatar picture (https), or empty.",
            "type": "string"
          },
          "category": {
            "description": "What they're streaming, or empty.",
            "type": "string"
          },
          "display_name": {
            "description": "The name as shown.",
            "type": "string"
          },
          "id": {
            "description": "The platform's id for the channel.",
            "type": "string"
          },
          "linked": {
            "description": "Their other channels, by explicit link only: a Velora channel's connected Twitch/Kick account its owner shared for raid matching. Never a name guess.",
            "items": {
              "additionalProperties": false,
              "properties": {
                "display_name": {
                  "description": "Its name as shown.",
                  "type": "string"
                },
                "id": {
                  "description": "That platform's id for the channel (matched on this, not the name).",
                  "type": "string"
                },
                "login": {
                  "description": "Its name there.",
                  "type": "string"
                },
                "platform": {
                  "description": "Where it is: twitch or kick.",
                  "type": "string"
                }
              },
              "required": [
                "platform",
                "id",
                "login",
                "display_name"
              ],
              "title": "RaidLinkedChannel",
              "type": "object"
            },
            "type": "array"
          },
          "login": {
            "description": "The name the platform raids by (raid.start's target).",
            "type": "string"
          },
          "title": {
            "description": "The stream's title.",
            "type": "string"
          },
          "viewers": {
            "description": "Watching now.",
            "type": "integer"
          }
        },
        "required": [
          "id",
          "login",
          "display_name",
          "avatar",
          "category",
          "title",
          "viewers",
          "linked"
        ],
        "title": "RaidTarget",
        "type": "object"
      },
      "via_chat": {
        "description": "Started with Velora's /raid chat command (an older Velora).",
        "type": "boolean"
      },
      "viewers": {
        "description": "How many went along, once sent (all platforms together).",
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "required": [
      "active",
      "generation",
      "raids"
    ],
    "title": "RaidStatus",
    "type": "object"
  }
}

captions.sendSend closed captions

Puts text into the stream and the recording as closed captions (CEA-608, as OBS sends them: Twitch, YouTube and video players show them). Long text is wrapped into 32-character caption lines; empty text clears the captions. Captions also clear by themselves after 10 seconds without new text. Dropped (delivered false) while nothing is live or recording.

Keyscope: control

Parameters

  • texttextrequired

    The caption text; empty clears.

    Up to 4000 characters

Result

  • clearedbooleanalways

    It was empty: the captions were cleared.

  • deliveredbooleanalways

    Something live or recording took it (false: dropped).

  • encodesintegeralways

    How many encodes took it (a vertical canvas is its own).

  • rowsintegeralways

    Caption lines the text made.

Live state

This action has no live state.

Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "captions.send",
  "params": {
    "text": "<text>"
  }
}

In the SDKs

C#
Task<CaptionsSendResult> CaptionsSendAsync(CaptionsSendParams parameters, CancellationToken cancellationToken = default)
TypeScript
captionsSend(params: CaptionsSendParams): Promise<CaptionsSendResult>
Python
async def captions_send(self, *, text: str) -> CaptionsSendResult
JSON Schema
JSON
{
  "params_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "additionalProperties": false,
    "properties": {
      "text": {
        "description": "The caption text; empty clears.",
        "maxLength": 4000,
        "type": "string"
      }
    },
    "required": [
      "text"
    ],
    "type": "object"
  },
  "result_schema": {
    "additionalProperties": false,
    "properties": {
      "cleared": {
        "description": "It was empty: the captions were cleared.",
        "type": "boolean"
      },
      "delivered": {
        "description": "Something live or recording took it (false: dropped).",
        "type": "boolean"
      },
      "encodes": {
        "description": "How many encodes took it (a vertical canvas is its own).",
        "type": "integer"
      },
      "rows": {
        "description": "Caption lines the text made.",
        "type": "integer"
      }
    },
    "required": [
      "delivered",
      "encodes",
      "rows",
      "cleared"
    ],
    "type": "object"
  }
}

to open · ↑ ↓ to move · Esc to close