Developer
Log in

Reference

State topics

32 topics. Subscribe to one and Studio sends its whole value right away, then again each time it changes. Replace what you had with each state notification.

TopicIts valueEvents it brings
activityActivityStateactivity.follow, activity.sub, activity.resub, activity.gift_sub, activity.support, activity.redemption, activity.raid, activity.card, activity.updated, obs.custom_event
app_volumeAppVolumeStatenone
audioAudioStatenone
audio_groupsAudioGroupsStatenone
automationsAutomationsStatenone
avatarsAvatarsStatenone
chatChatStatechat.message, chat.deleted, chat.edited, chat.cleared
collectionsCollectionsStatenone
destinationsDestinationsStatenone
dynamicDynamicStatenone
filtersFiltersStatenone
gpusGpusStatenone
layersLayersStatenone
mediaMediaStatemedia.changed
metersMetersStatenone
ndiNdiStatenone
networkNetworkStatenone
recordRecordStaterecord.paused, record.resumed
replayReplayStatereplay.started, replay.stopped, replay.saved
scenesScenesStatescene.changed
source_settingsSourceSettingsStatenone
sourcesSourcesStatenone
statsStatsStatenone
streamStreamStatecaptions.sent
stream_infoStreamInfoStatenone
themeThemeStatenone
transitionsTransitionsStatenone
updateUpdateStatenone
variablesVariablesStatenone
vcamVcamStatenone
veloqVeloqStatenone
webWebStateweb.changed

activityActivityState

Brings activity.follow, activity.sub, activity.resub, activity.gift_sub, activity.support, activity.redemption, activity.raid, activity.card, activity.updated, obs.custom_event.

Value

  • recentarray of ChatRowalways

    The last 50 activity rows.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Activity);
var value = studio.State.Activity;  // ActivityState
TypeScript
await studio.subscribe("activity");
const value = studio.state.activity;  // ActivityState
Python
await studio.subscribe(TopicType.ACTIVITY)
value = studio.state.activity
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "recent": {
      "description": "The last 50 activity rows.",
      "items": {
        "additionalProperties": false,
        "description": "One row of chat or one activity, as Studio's chat panel shows it.",
        "properties": {
          "accent": {
            "description": "An accent color the platform gives it, \"#RRGGBB\".",
            "type": [
              "string",
              "null"
            ]
          },
          "amount": {
            "additionalProperties": false,
            "description": "Support with a number, kept as a value and its unit, never as text read as money.",
            "properties": {
              "display": {
                "description": "As the platform shows it, such as \"1,000 bits\" or \"$4.99\".",
                "type": "string"
              },
              "months": {
                "type": [
                  "integer",
                  "null"
                ]
              },
              "tier": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "unit": {
                "description": "volts, bits, kicks, points, subs (a gift's count), viewers (a raid's), or a currency code such as USD for real money.",
                "type": "string"
              },
              "value": {
                "type": "number"
              }
            },
            "required": [
              "value",
              "unit",
              "display",
              "tier",
              "months"
            ],
            "title": "ChatAmount",
            "type": [
              "object",
              "null"
            ]
          },
          "art": {
            "description": "The platform's own picture for it (a reward's art).",
            "type": [
              "string",
              "null"
            ]
          },
          "author": {
            "additionalProperties": false,
            "properties": {
              "avatar": {
                "description": "A link to their picture.",
                "type": [
                  "string",
                  "null"
                ]
              },
              "badges": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "image": {
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "label": {
                      "description": "Shown on hover.",
                      "type": "string"
                    },
                    "rotates": {
                      "description": "One of the badges that take turns in one place (Velora's badge strip); absent = false.",
                      "type": "boolean"
                    }
                  },
                  "required": [
                    "id",
                    "label",
                    "image"
                  ],
                  "title": "ChatBadge",
                  "type": "object"
                },
                "type": "array"
              },
              "color": {
                "description": "Their name's color, \"#RRGGBB\".",
                "type": [
                  "string",
                  "null"
                ]
              },
              "display": {
                "description": "Their display name.",
                "type": "string"
              },
              "id": {
                "description": "Their id on the platform.",
                "type": "string"
              },
              "login": {
                "description": "Their login name.",
                "type": "string"
              },
              "pronouns": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "roles": {
                "additionalProperties": false,
                "properties": {
                  "bot": {
                    "type": "boolean"
                  },
                  "broadcaster": {
                    "type": "boolean"
                  },
                  "moderator": {
                    "type": "boolean"
                  },
                  "staff": {
                    "type": "boolean"
                  },
                  "subscriber": {
                    "type": "boolean"
                  },
                  "vip": {
                    "type": "boolean"
                  }
                },
                "required": [
                  "broadcaster",
                  "moderator",
                  "vip",
                  "subscriber",
                  "bot",
                  "staff"
                ],
                "title": "ChatRoles",
                "type": "object"
              }
            },
            "required": [
              "id",
              "login",
              "display",
              "color",
              "avatar",
              "pronouns",
              "roles",
              "badges"
            ],
            "title": "ChatAuthor",
            "type": [
              "object",
              "null"
            ]
          },
          "channel": {
            "description": "The channel's id on its platform.",
            "type": "string"
          },
          "eid": {
            "description": "Studio's number for this row, for chat.deleted and chat.edited.",
            "type": "integer"
          },
          "flags": {
            "additionalProperties": false,
            "properties": {
              "edited": {
                "type": "boolean"
              },
              "first_message": {
                "type": "boolean"
              },
              "highlighted": {
                "type": "boolean"
              },
              "own": {
                "description": "Sent from this Studio.",
                "type": "boolean"
              },
              "replay": {
                "description": "An alert shown again on stream.",
                "type": "boolean"
              }
            },
            "required": [
              "first_message",
              "highlighted",
              "edited",
              "own",
              "replay"
            ],
            "title": "ChatFlags",
            "type": "object"
          },
          "kind": {
            "enum": [
              "message",
              "action",
              "system",
              "bot",
              "announcement",
              "follow",
              "sub",
              "resub",
              "gift_sub",
              "support",
              "redemption",
              "raid",
              "card"
            ],
            "title": "ChatRowKind",
            "type": "string"
          },
          "meta": {
            "description": "Anything else the platform sent that Studio doesn't describe yet. Any JSON; don't rely on its shape."
          },
          "native_id": {
            "description": "The platform's id for this message.",
            "type": [
              "string",
              "null"
            ]
          },
          "parts": {
            "items": {
              "description": "A piece of a message, told apart by t: text, an emote, a mention, a link, or styled words (Velora chat's **bold** and *italic*).",
              "oneOf": [
                {
                  "additionalProperties": false,
                  "properties": {
                    "t": {
                      "const": "text"
                    },
                    "text": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "t",
                    "text"
                  ],
                  "type": "object"
                },
                {
                  "additionalProperties": false,
                  "properties": {
                    "animated": {
                      "type": "boolean"
                    },
                    "code": {
                      "description": "What was typed.",
                      "type": "string"
                    },
                    "scales": {
                      "description": "Its 1x, 2x and 4x pictures, when the service has them.",
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    },
                    "source": {
                      "description": "Where it's from, such as \"7TV · channel\".",
                      "type": "string"
                    },
                    "t": {
                      "const": "emote"
                    },
                    "url": {
                      "description": "The emote's picture (2x).",
                      "type": "string"
                    },
                    "zero_width": {
                      "description": "Drawn on top of the emote before it.",
                      "type": "boolean"
                    }
                  },
                  "required": [
                    "t",
                    "code",
                    "url",
                    "animated"
                  ],
                  "type": "object"
                },
                {
                  "additionalProperties": false,
                  "properties": {
                    "login": {
                      "type": "string"
                    },
                    "t": {
                      "const": "mention"
                    }
                  },
                  "required": [
                    "t",
                    "login"
                  ],
                  "type": "object"
                },
                {
                  "additionalProperties": false,
                  "properties": {
                    "t": {
                      "const": "link"
                    },
                    "url": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "t",
                    "url"
                  ],
                  "type": "object"
                },
                {
                  "additionalProperties": false,
                  "properties": {
                    "bold": {
                      "type": "boolean"
                    },
                    "italic": {
                      "type": "boolean"
                    },
                    "t": {
                      "const": "styled"
                    },
                    "text": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "t",
                    "text"
                  ],
                  "type": "object"
                }
              ],
              "title": "ChatPart"
            },
            "type": "array"
          },
          "platform": {
            "enum": [
              "velora",
              "twitch",
              "kick",
              "youtube",
              "owncast",
              "rumble"
            ],
            "title": "ChatPlatform",
            "type": "string"
          },
          "reply_to": {
            "additionalProperties": false,
            "properties": {
              "author": {
                "type": "string"
              },
              "excerpt": {
                "type": "string"
              },
              "native_id": {
                "type": "string"
              }
            },
            "required": [
              "native_id",
              "author",
              "excerpt"
            ],
            "title": "ChatReplyTo",
            "type": [
              "object",
              "null"
            ]
          },
          "state": {
            "description": "live, or deleted (with who deleted it, when known).",
            "oneOf": [
              {
                "additionalProperties": false,
                "properties": {
                  "t": {
                    "const": "live"
                  }
                },
                "required": [
                  "t"
                ],
                "type": "object"
              },
              {
                "additionalProperties": false,
                "properties": {
                  "by": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "t": {
                    "const": "deleted"
                  }
                },
                "required": [
                  "t",
                  "by"
                ],
                "type": "object"
              }
            ],
            "title": "ChatRowState"
          },
          "text": {
            "description": "The plain text.",
            "type": "string"
          },
          "title": {
            "description": "A card's headline: a reward's title, \"Poll ended\"…",
            "type": [
              "string",
              "null"
            ]
          },
          "ts": {
            "description": "When, in Unix milliseconds.",
            "type": "integer"
          }
        },
        "required": [
          "eid",
          "platform",
          "channel",
          "native_id",
          "ts",
          "kind",
          "author",
          "parts",
          "text",
          "reply_to",
          "amount",
          "title",
          "art",
          "accent",
          "flags",
          "state",
          "meta"
        ],
        "title": "ChatRow",
        "type": "object"
      },
      "type": "array"
    }
  },
  "required": [
    "recent"
  ],
  "title": "ActivityState",
  "type": "object"
}

app_volumeAppVolumeState

Lights audio.app_volume.

Value

  • itemsmap of id → AppVolumealways

    Each application-audio source by id: its app's own volume in Windows (the Volume Mixer's slider, what you hear), read about once a second. Not the source's fader (audio.volume, what viewers hear).

    Fields of items
    • errorstringalwayscan be null

      Why there's no volume to read: the app isn't running, has no audio session yet, or this isn't Windows.

    • executablestringalways

      The app's executable file name, such as Discord.exe.

    • keeps_stream_levelbooleanalways

      The source captures the app at its full level whatever this volume (its "ignore the app's Windows volume" setting); otherwise what Velum captures follows it, as Windows applies it before the capture.

    • mutedbooleanalwayscan be null

      Windows' mute for the app; null when there's none to read.

    • namestringalways

      The source's name.

    • sessionsintegeralways

      The app's audio sessions on this computer's outputs.

    • volume_percentnumberalwayscan be null

      Windows' volume for the app, 0 to 100 as its Volume Mixer shows it; null when there's none to read (see error).

      0 to 100

In the SDKs

C#
await studio.SubscribeAsync(TopicType.AppVolume);
var value = studio.State.AppVolume;  // AppVolumeState
TypeScript
await studio.subscribe("app_volume");
const value = studio.state.app_volume;  // AppVolumeState
Python
await studio.subscribe(TopicType.APP_VOLUME)
value = studio.state.app_volume
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "error": {
            "description": "Why there's no volume to read: the app isn't running, has no audio session yet, or this isn't Windows.",
            "type": [
              "string",
              "null"
            ]
          },
          "executable": {
            "description": "The app's executable file name, such as Discord.exe.",
            "type": "string"
          },
          "keeps_stream_level": {
            "description": "The source captures the app at its full level whatever this volume (its \"ignore the app's Windows volume\" setting); otherwise what Velum captures follows it, as Windows applies it before the capture.",
            "type": "boolean"
          },
          "muted": {
            "description": "Windows' mute for the app; null when there's none to read.",
            "type": [
              "boolean",
              "null"
            ]
          },
          "name": {
            "description": "The source's name.",
            "type": "string"
          },
          "sessions": {
            "description": "The app's audio sessions on this computer's outputs.",
            "type": "integer"
          },
          "volume_percent": {
            "description": "Windows' volume for the app, 0 to 100 as its Volume Mixer shows it; null when there's none to read (see error).",
            "maximum": 100,
            "minimum": 0,
            "type": [
              "number",
              "null"
            ]
          }
        },
        "required": [
          "name",
          "executable",
          "volume_percent",
          "muted",
          "sessions",
          "keeps_stream_level",
          "error"
        ],
        "title": "AppVolume",
        "type": "object"
      },
      "description": "Each application-audio source by id: its app's own volume in Windows (the Volume Mixer's slider, what you hear), read about once a second. Not the source's fader (audio.volume, what viewers hear).",
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "AppVolumeState",
  "type": "object"
}

audioAudioState

Lights audio.mute, audio.volume, audio.monitor, audio.monitor_when, audio.monitor_send, audio.track, veloq.visibility, veloq.viewer_start, veloq.stem, veloq.group, veloq.slider_order.

Value

  • itemsmap of id → AudioInputalways
    Fields of items
    • groupstring (uuid)alwayscan be null

      The audio folder or send it's in (the audio_groups topic), or null.

    • idstring (uuid)always
    • monitorMonitorMode (string)always

      One of "off" "monitor_only" "monitor_and_output"

    • monitor_sendsarray of numberoptional

      Each: 0 to 1 · Up to 4 items

    • monitor_whenMonitorWhen (string)always

      When the headphones hear it: setting (as Studio's Settings › Audio › Headphones play only what's on air says), always, or on_air (only while a scene on the program has it, fading with the transition).

      One of "setting" "always" "on_air"

    • mutedbooleanalways
    • namestringalways
    • slider_orderintegeralways

      Its place in who gets the 8 viewer sliders first (0 = automatic).

    • stembooleanalways

      Recorded as its own Editor+ stem when it's mixed with others.

    • tracksmap of id → booleanalways

      Tracks "1" to "6": on or off.

    • viewer_mutedbooleanalways

      A viewer's slider for it starts muted.

    • viewer_volumenumberalways

      Where a viewer's slider for it starts (1 = full).

      0 to 1

    • visibilityVeloqVisibility (string)always

      Where its sound goes for Velora viewers over VELoQ: public (viewers can adjust it), public_drop_vod (viewers can adjust it; not in the VOD), hidden_keep_vod and hidden_drop_vod (heard with no slider of its own, in the VOD or not), not_sent (never leaves Studio).

      One of "public" "public_drop_vod" "hidden_keep_vod" "hidden_drop_vod" "not_sent"

    • volume_dbnumberalwayscan be null

      The gain in dB; null is silent.

    • volume_percentnumberalways

      The mixer fader's position, 0 to 100.

      0 to 100

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Audio);
var value = studio.State.Audio;  // AudioState
TypeScript
await studio.subscribe("audio");
const value = studio.state.audio;  // AudioState
Python
await studio.subscribe(TopicType.AUDIO)
value = studio.state.audio
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "group": {
            "description": "The audio folder or send it's in (the audio_groups topic), or null.",
            "format": "uuid",
            "type": [
              "string",
              "null"
            ]
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "monitor": {
            "enum": [
              "off",
              "monitor_only",
              "monitor_and_output"
            ],
            "title": "MonitorMode",
            "type": "string"
          },
          "monitor_sends": {
            "items": {
              "maximum": 1,
              "minimum": 0,
              "type": "number"
            },
            "maxItems": 4,
            "minItems": 4,
            "type": "array"
          },
          "monitor_when": {
            "description": "When the headphones hear it: setting (as Studio's Settings › Audio › Headphones play only what's on air says), always, or on_air (only while a scene on the program has it, fading with the transition).",
            "enum": [
              "setting",
              "always",
              "on_air"
            ],
            "title": "MonitorWhen",
            "type": "string"
          },
          "muted": {
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "slider_order": {
            "description": "Its place in who gets the 8 viewer sliders first (0 = automatic).",
            "type": "integer"
          },
          "stem": {
            "description": "Recorded as its own Editor+ stem when it's mixed with others.",
            "type": "boolean"
          },
          "tracks": {
            "additionalProperties": {
              "type": "boolean"
            },
            "description": "Tracks \"1\" to \"6\": on or off.",
            "type": "object"
          },
          "viewer_muted": {
            "description": "A viewer's slider for it starts muted.",
            "type": "boolean"
          },
          "viewer_volume": {
            "description": "Where a viewer's slider for it starts (1 = full).",
            "maximum": 1,
            "minimum": 0,
            "type": "number"
          },
          "visibility": {
            "description": "Where its sound goes for Velora viewers over VELoQ: public (viewers can adjust it), public_drop_vod (viewers can adjust it; not in the VOD), hidden_keep_vod and hidden_drop_vod (heard with no slider of its own, in the VOD or not), not_sent (never leaves Studio).",
            "enum": [
              "public",
              "public_drop_vod",
              "hidden_keep_vod",
              "hidden_drop_vod",
              "not_sent"
            ],
            "title": "VeloqVisibility",
            "type": "string"
          },
          "volume_db": {
            "description": "The gain in dB; null is silent.",
            "type": [
              "number",
              "null"
            ]
          },
          "volume_percent": {
            "description": "The mixer fader's position, 0 to 100.",
            "maximum": 100,
            "minimum": 0,
            "type": "number"
          }
        },
        "required": [
          "id",
          "name",
          "muted",
          "volume_db",
          "volume_percent",
          "monitor",
          "monitor_when",
          "tracks",
          "visibility",
          "group",
          "stem",
          "viewer_volume",
          "viewer_muted",
          "slider_order"
        ],
        "title": "AudioInput",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "AudioState",
  "type": "object"
}

audio_groupsAudioGroupsState

Lights veloq.update_group.

Value

  • itemsmap of id → AudioGroupalways
    Fields of items
    • idstring (uuid)always
    • kindAudioGroupKind (string)always

      folder (each source keeps its own slider, shown together) or send (one slider for all of them).

      One of "folder" "send"

    • membersarray of string (uuid)always

      The sources in it.

    • namestringalways

      What viewers see over its sliders (a folder) or on its slider (a send).

    • send_visibilityVeloqVisibility (string)always

      A send's slider: public or public_drop_vod (a folder's is unused).

      One of "public" "public_drop_vod" "hidden_keep_vod" "hidden_drop_vod" "not_sent"

In the SDKs

C#
await studio.SubscribeAsync(TopicType.AudioGroups);
var value = studio.State.AudioGroups;  // AudioGroupsState
TypeScript
await studio.subscribe("audio_groups");
const value = studio.state.audio_groups;  // AudioGroupsState
Python
await studio.subscribe(TopicType.AUDIO_GROUPS)
value = studio.state.audio_groups
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "kind": {
            "description": "folder (each source keeps its own slider, shown together) or send (one slider for all of them).",
            "enum": [
              "folder",
              "send"
            ],
            "title": "AudioGroupKind",
            "type": "string"
          },
          "members": {
            "description": "The sources in it.",
            "items": {
              "format": "uuid",
              "type": "string"
            },
            "type": "array"
          },
          "name": {
            "description": "What viewers see over its sliders (a folder) or on its slider (a send).",
            "type": "string"
          },
          "send_visibility": {
            "description": "A send's slider: public or public_drop_vod (a folder's is unused).",
            "enum": [
              "public",
              "public_drop_vod",
              "hidden_keep_vod",
              "hidden_drop_vod",
              "not_sent"
            ],
            "title": "VeloqVisibility",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "kind",
          "send_visibility",
          "members"
        ],
        "title": "AudioGroup",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "AudioGroupsState",
  "type": "object"
}

automationsAutomationsState

Lights automation.run, automation.enable.

Value

  • itemsmap of id → Automationalways
    Fields of items
    • enabledbooleanalways
    • idstring (uuid)always
    • namestringalways

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Automations);
var value = studio.State.Automations;  // AutomationsState
TypeScript
await studio.subscribe("automations");
const value = studio.state.automations;  // AutomationsState
Python
await studio.subscribe(TopicType.AUTOMATIONS)
value = studio.state.automations
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "enabled": {
            "type": "boolean"
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "name": {
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "enabled"
        ],
        "title": "Automation",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "AutomationsState",
  "type": "object"
}

avatarsAvatarsState

Lights avatar.lipsync.

Value

  • featurebooleanalways

    Avatars is turned on (Settings › Advanced › Avatars). Off, no pairing runs and items is empty.

  • itemsmap of id → AvatarPairingalways

    Each lip-sync pairing by id: a voice in Studio moving an avatar's mouth in an avatar app.

    Fields of items
    • enabledbooleanalways

      Turned on (avatar.lipsync).

    • namestringalways
    • protocolstringalways

      How: vmc (VMC, OSC over UDP).

    • sourcestringalwayscan be null

      The audio source whose voice it follows (id), once found.

    • source_namestringalways

      That source's name.

    • statestringalways

      What it's doing: off, sending, muted (the source is muted), waiting (the source isn't capturing or in a scene), no_source (not in this collection), resolving, unknown_host, error, invalid.

    • targetstringalways

      Where it sends: the avatar app's host:port.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Avatars);
var value = studio.State.Avatars;  // AvatarsState
TypeScript
await studio.subscribe("avatars");
const value = studio.state.avatars;  // AvatarsState
Python
await studio.subscribe(TopicType.AVATARS)
value = studio.state.avatars
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "feature": {
      "description": "Avatars is turned on (Settings › Advanced › Avatars). Off, no pairing runs and items is empty.",
      "type": "boolean"
    },
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "enabled": {
            "description": "Turned on (avatar.lipsync).",
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "protocol": {
            "description": "How: vmc (VMC, OSC over UDP).",
            "type": "string"
          },
          "source": {
            "description": "The audio source whose voice it follows (id), once found.",
            "type": [
              "string",
              "null"
            ]
          },
          "source_name": {
            "description": "That source's name.",
            "type": "string"
          },
          "state": {
            "description": "What it's doing: off, sending, muted (the source is muted), waiting (the source isn't capturing or in a scene), no_source (not in this collection), resolving, unknown_host, error, invalid.",
            "type": "string"
          },
          "target": {
            "description": "Where it sends: the avatar app's host:port.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "enabled",
          "state",
          "source",
          "source_name",
          "target",
          "protocol"
        ],
        "title": "AvatarPairing",
        "type": "object"
      },
      "description": "Each lip-sync pairing by id: a voice in Studio moving an avatar's mouth in an avatar app.",
      "type": "object"
    }
  },
  "required": [
    "feature",
    "items"
  ],
  "title": "AvatarsState",
  "type": "object"
}

chatChatState

Brings chat.message, chat.deleted, chat.edited, chat.cleared. Lights chat.mode.

Value

  • connectionsmap of id → one ofalways

    Each platform's chat connection.

    Fields of connections
    • When t: "connecting"

      • t = "connecting"always
    • When t: "live"

      • t = "live"always
    • When t: "retrying"

      • t = "retrying"always
      • whystringalways
    • When t: "stopped"

      • t = "stopped"always
      • whystringalways
  • litarray of stringalways

    Where a message goes when no platform is named: the chats lit under All in the chat panel.

  • modesmap of id → ChatModesalways

    Each platform's chat modes, once read.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Chat);
var value = studio.State.Chat;  // ChatState
TypeScript
await studio.subscribe("chat");
const value = studio.state.chat;  // ChatState
Python
await studio.subscribe(TopicType.CHAT)
value = studio.state.chat
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "connections": {
      "additionalProperties": {
        "description": "connecting, live, retrying (lost; trying again, with why) or stopped (can't go on without you: signed out, no permission, with why).",
        "oneOf": [
          {
            "additionalProperties": false,
            "properties": {
              "t": {
                "const": "connecting"
              }
            },
            "required": [
              "t"
            ],
            "type": "object"
          },
          {
            "additionalProperties": false,
            "properties": {
              "t": {
                "const": "live"
              }
            },
            "required": [
              "t"
            ],
            "type": "object"
          },
          {
            "additionalProperties": false,
            "properties": {
              "t": {
                "const": "retrying"
              },
              "why": {
                "type": "string"
              }
            },
            "required": [
              "t",
              "why"
            ],
            "type": "object"
          },
          {
            "additionalProperties": false,
            "properties": {
              "t": {
                "const": "stopped"
              },
              "why": {
                "type": "string"
              }
            },
            "required": [
              "t",
              "why"
            ],
            "type": "object"
          }
        ],
        "title": "ChatConnection"
      },
      "description": "Each platform's chat connection.",
      "type": "object"
    },
    "lit": {
      "description": "Where a message goes when no platform is named: the chats lit under All in the chat panel.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "modes": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "emote_only": {
            "type": "boolean"
          },
          "followers_only": {
            "type": "boolean"
          },
          "slow_seconds": {
            "description": "Slow mode's wait between messages; null while slow mode is off.",
            "type": [
              "integer",
              "null"
            ]
          },
          "subscribers_only": {
            "type": "boolean"
          }
        },
        "required": [
          "slow_seconds",
          "followers_only",
          "subscribers_only",
          "emote_only"
        ],
        "title": "ChatModes",
        "type": "object"
      },
      "description": "Each platform's chat modes, once read.",
      "type": "object"
    }
  },
  "required": [
    "connections",
    "lit",
    "modes"
  ],
  "title": "ChatState",
  "type": "object"
}

collectionsCollectionsState

Lights collection.switch.

Value

  • currentstringalwayscan be null

    The open collection's id.

  • current_namestringalwayscan be null
  • itemsmap of id → CollectionRefalways
    Fields of items
    • idstringalways
    • namestringalways

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Collections);
var value = studio.State.Collections;  // CollectionsState
TypeScript
await studio.subscribe("collections");
const value = studio.state.collections;  // CollectionsState
Python
await studio.subscribe(TopicType.COLLECTIONS)
value = studio.state.collections
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "current": {
      "description": "The open collection's id.",
      "type": [
        "string",
        "null"
      ]
    },
    "current_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "id": {
            "type": "string"
          },
          "name": {
            "type": "string"
          }
        },
        "required": [
          "id",
          "name"
        ],
        "title": "CollectionRef",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "current",
    "current_name",
    "items"
  ],
  "title": "CollectionsState",
  "type": "object"
}

destinationsDestinationsState

Lights destination.select, destination.start, destination.stop, destination.reconnect, destination.audio, destination.health.

Value

  • itemsmap of id → Destinationalways
    Fields of items
    • audio_mixAudioMix (string)optionalcan be null

      Its Audio sent: full (the stream's full mix) or vod_safe (without the sources marked Live only, so they stay out of that platform's VOD; its live viewers don't hear them either). Null for Velora, which takes none: it leaves Live-only sources out of its VOD itself.

      One of "full" "vod_safe" null

    • healthDestinationHealthalways
    • idstringalways

      velora, platform:<id> or whip:<12 hex digits>.

    • kindDestinationKind (string)always

      One of "velora" "platform" "whip"

    • layersintegeroptionalcan be null

      Velora over VELoQ: how many qualities are sent (1 to 4; null = the default, 2).

    • livebooleanalways

      The stream is going here now.

    • namestringalways
    • platformstringoptional

      The platform, such as twitch, for kind platform.

    • protocolStreamProtocol (string)optionalcan be null

      How it's sent: veloq or whip for Velora (veloq wherever this copy can send it); rtmps, rtmp or srt for platforms and servers.

      One of "whip" "veloq" "rtmps" "rtmp" "srt" null

    • selectedbooleanalways

      Where Go live sends when no destination is named.

  • selectedstringalwayscan be null

    The id of the selected destination.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Destinations);
var value = studio.State.Destinations;  // DestinationsState
TypeScript
await studio.subscribe("destinations");
const value = studio.state.destinations;  // DestinationsState
Python
await studio.subscribe(TopicType.DESTINATIONS)
value = studio.state.destinations
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "audio_mix": {
            "description": "Its Audio sent: full (the stream's full mix) or vod_safe (without the sources marked Live only, so they stay out of that platform's VOD; its live viewers don't hear them either). Null for Velora, which takes none: it leaves Live-only sources out of its VOD itself.",
            "enum": [
              "full",
              "vod_safe",
              null
            ],
            "title": "AudioMix",
            "type": [
              "string",
              "null"
            ]
          },
          "health": {
            "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"
          },
          "id": {
            "description": "velora, platform:<id> or whip:<12 hex digits>.",
            "type": "string"
          },
          "kind": {
            "enum": [
              "velora",
              "platform",
              "whip"
            ],
            "title": "DestinationKind",
            "type": "string"
          },
          "layers": {
            "description": "Velora over VELoQ: how many qualities are sent (1 to 4; null = the default, 2).",
            "type": [
              "integer",
              "null"
            ]
          },
          "live": {
            "description": "The stream is going here now.",
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "platform": {
            "description": "The platform, such as twitch, for kind platform.",
            "type": "string"
          },
          "protocol": {
            "description": "How it's sent: veloq or whip for Velora (veloq wherever this copy can send it); rtmps, rtmp or srt for platforms and servers.",
            "enum": [
              "whip",
              "veloq",
              "rtmps",
              "rtmp",
              "srt",
              null
            ],
            "title": "StreamProtocol",
            "type": [
              "string",
              "null"
            ]
          },
          "selected": {
            "description": "Where Go live sends when no destination is named.",
            "type": "boolean"
          }
        },
        "required": [
          "id",
          "name",
          "kind",
          "selected",
          "live",
          "health"
        ],
        "title": "Destination",
        "type": "object"
      },
      "type": "object"
    },
    "selected": {
      "description": "The id of the selected destination.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "selected",
    "items"
  ],
  "title": "DestinationsState",
  "type": "object"
}

dynamicDynamicState

Lights dynamic.set_variable.

Value

  • categorystringalwayscan be null

    The category Dynamic Sources match against.

  • titlestringalwayscan be null

    The title Dynamic Sources match against.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Dynamic);
var value = studio.State.Dynamic;  // DynamicState
TypeScript
await studio.subscribe("dynamic");
const value = studio.state.dynamic;  // DynamicState
Python
await studio.subscribe(TopicType.DYNAMIC)
value = studio.state.dynamic
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "category": {
      "description": "The category Dynamic Sources match against.",
      "type": [
        "string",
        "null"
      ]
    },
    "title": {
      "description": "The title Dynamic Sources match against.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "category",
    "title"
  ],
  "title": "DynamicState",
  "type": "object"
}

filtersFiltersState

Lights filter.toggle, filter.set.

Value

  • itemsmap of id → Effectalways
    Fields of items
    • enabledbooleanalways
    • idstring (uuid)always
    • indexintegeralways
    • namestringalways
    • ownerstring (uuid)always

      The source or scene it's on.

    • owner_namestringalways
    • settingsmap of id → number or boolean or stringalways

      The effect's settings now, by key.

    • typestringalways

      The effect's type, such as velum.filter.chroma_key; filter_settings in catalog.list describes each type's settings.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Filters);
var value = studio.State.Filters;  // FiltersState
TypeScript
await studio.subscribe("filters");
const value = studio.state.filters;  // FiltersState
Python
await studio.subscribe(TopicType.FILTERS)
value = studio.state.filters
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "enabled": {
            "type": "boolean"
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "index": {
            "type": "integer"
          },
          "name": {
            "type": "string"
          },
          "owner": {
            "description": "The source or scene it's on.",
            "format": "uuid",
            "type": "string"
          },
          "owner_name": {
            "type": "string"
          },
          "settings": {
            "additionalProperties": {
              "type": [
                "number",
                "boolean",
                "string"
              ]
            },
            "description": "The effect's settings now, by key.",
            "type": "object"
          },
          "type": {
            "description": "The effect's type, such as velum.filter.chroma_key; filter_settings in catalog.list describes each type's settings.",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "type",
          "owner",
          "owner_name",
          "index",
          "enabled",
          "settings"
        ],
        "title": "Effect",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "FiltersState",
  "type": "object"
}

gpusGpusState

Lights gpu.draw_on, gpu.encode_on.

Value

  • draw_fallbackstringalwayscan be null

    Why Studio isn't drawing on the card chosen (it's gone, or wouldn't open): it draws as auto meanwhile.

  • draw_onstringalways

    Draw scenes on: auto, or the chosen card's key.

  • draw_pendingbooleanalways

    A new Draw scenes on waits for the stream and recording to stop.

  • drawingstringalwayscan be null

    The key of the card Studio draws on now (null before it has started).

  • encode_onstringalways

    Encode on: auto, software (x264), or the chosen card's key.

  • itemsmap of id → GraphicsCardalways

    Every graphics card by its key (pci:05:00.0 where the system names the slot, else luid:… or name:…).

    Fields of items
    • drawingbooleanalways

      Studio draws its scenes on it now.

    • encoderstringalwayscan be null

      Its hardware encoder (NVENC, AMD AMF, Intel Quick Sync, VA-API, VideoToolbox), null for none.

    • encoder_worksbooleanalways

      Its encoder opened when Studio tried it.

    • encodingbooleanalways

      A stream or recording encodes on it now.

    • kindstringalways

      discrete, integrated, virtual, software or other.

    • labelstringalways

      Its name, with #1, #2 in slot order when two cards share it.

    • memory_bytesintegeralwayscan be null

      Its video memory, where the system says.

    • monitorsarray of stringalways

      The monitors it drives, by name (where the system says).

    • namestringalways

      As its driver names it.

    • pcistringalwayscan be null

      Its PCI slot (bus:device.function), where the system says.

    • vendorstringalways

      NVIDIA, AMD, Intel, Apple, or empty.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Gpus);
var value = studio.State.Gpus;  // GpusState
TypeScript
await studio.subscribe("gpus");
const value = studio.state.gpus;  // GpusState
Python
await studio.subscribe(TopicType.GPUS)
value = studio.state.gpus
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "draw_fallback": {
      "description": "Why Studio isn't drawing on the card chosen (it's gone, or wouldn't open): it draws as auto meanwhile.",
      "type": [
        "string",
        "null"
      ]
    },
    "draw_on": {
      "description": "Draw scenes on: auto, or the chosen card's key.",
      "type": "string"
    },
    "draw_pending": {
      "description": "A new Draw scenes on waits for the stream and recording to stop.",
      "type": "boolean"
    },
    "drawing": {
      "description": "The key of the card Studio draws on now (null before it has started).",
      "type": [
        "string",
        "null"
      ]
    },
    "encode_on": {
      "description": "Encode on: auto, software (x264), or the chosen card's key.",
      "type": "string"
    },
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "drawing": {
            "description": "Studio draws its scenes on it now.",
            "type": "boolean"
          },
          "encoder": {
            "description": "Its hardware encoder (NVENC, AMD AMF, Intel Quick Sync, VA-API, VideoToolbox), null for none.",
            "type": [
              "string",
              "null"
            ]
          },
          "encoder_works": {
            "description": "Its encoder opened when Studio tried it.",
            "type": "boolean"
          },
          "encoding": {
            "description": "A stream or recording encodes on it now.",
            "type": "boolean"
          },
          "kind": {
            "description": "discrete, integrated, virtual, software or other.",
            "type": "string"
          },
          "label": {
            "description": "Its name, with #1, #2 in slot order when two cards share it.",
            "type": "string"
          },
          "memory_bytes": {
            "description": "Its video memory, where the system says.",
            "type": [
              "integer",
              "null"
            ]
          },
          "monitors": {
            "description": "The monitors it drives, by name (where the system says).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "name": {
            "description": "As its driver names it.",
            "type": "string"
          },
          "pci": {
            "description": "Its PCI slot (bus:device.function), where the system says.",
            "type": [
              "string",
              "null"
            ]
          },
          "vendor": {
            "description": "NVIDIA, AMD, Intel, Apple, or empty.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "label",
          "vendor",
          "kind",
          "pci",
          "memory_bytes",
          "monitors",
          "encoder",
          "encoder_works",
          "drawing",
          "encoding"
        ],
        "title": "GraphicsCard",
        "type": "object"
      },
      "description": "Every graphics card by its key (pci:05:00.0 where the system names the slot, else luid:… or name:…).",
      "type": "object"
    }
  },
  "required": [
    "items",
    "draw_on",
    "encode_on",
    "drawing",
    "draw_fallback",
    "draw_pending"
  ],
  "title": "GpusState",
  "type": "object"
}

layersLayersState

Lights layer.visibility, layer.restart, layer.freeze_on_air, layer.opacity, layer.clip, layer.framing.

Value

  • itemsmap of id → Layeralways
    Fields of items
    • clippedbooleanalways

      Shows only where the layer under it has a picture (clip to layer below).

    • framingstring (uuid)alwayscan be null

      The framing it sits in now; null when it's somewhere else.

    • framingsarray of FramingRefalways

      Its saved framings, in the Framings list's order.

      Fields of framings
      • idstring (uuid)always
      • namestringalways
    • freeze_on_airbooleanalways

      Shows the picture it had when its scene came on air.

    • idstring (uuid)always
    • indexintegeralways

      Its place in the scene's layer list, from 0.

    • kindLayerKind (string)always

      What it places: a source or a scene.

      One of "source" "scene"

    • lockedbooleanalways
    • namestringalways
    • opacitynumberalways

      How see-through it is, 0 (gone) to 100 (solid).

      0 to 100

    • scenestring (uuid)always

      The scene it's in.

    • scene_item_idintegeralways

      Its per-scene number.

    • scene_namestringalways
    • targetstring (uuid)always

      The id of the source or scene it places.

    • visiblebooleanalways

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Layers);
var value = studio.State.Layers;  // LayersState
TypeScript
await studio.subscribe("layers");
const value = studio.state.layers;  // LayersState
Python
await studio.subscribe(TopicType.LAYERS)
value = studio.state.layers
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "clipped": {
            "description": "Shows only where the layer under it has a picture (clip to layer below).",
            "type": "boolean"
          },
          "framing": {
            "description": "The framing it sits in now; null when it's somewhere else.",
            "format": "uuid",
            "type": [
              "string",
              "null"
            ]
          },
          "framings": {
            "description": "Its saved framings, in the Framings list's order.",
            "items": {
              "additionalProperties": false,
              "properties": {
                "id": {
                  "format": "uuid",
                  "type": "string"
                },
                "name": {
                  "type": "string"
                }
              },
              "required": [
                "id",
                "name"
              ],
              "title": "FramingRef",
              "type": "object"
            },
            "type": "array"
          },
          "freeze_on_air": {
            "description": "Shows the picture it had when its scene came on air.",
            "type": "boolean"
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "index": {
            "description": "Its place in the scene's layer list, from 0.",
            "type": "integer"
          },
          "kind": {
            "description": "What it places: a source or a scene.",
            "enum": [
              "source",
              "scene"
            ],
            "title": "LayerKind",
            "type": "string"
          },
          "locked": {
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "opacity": {
            "description": "How see-through it is, 0 (gone) to 100 (solid).",
            "maximum": 100,
            "minimum": 0,
            "type": "number"
          },
          "scene": {
            "description": "The scene it's in.",
            "format": "uuid",
            "type": "string"
          },
          "scene_item_id": {
            "description": "Its per-scene number.",
            "type": "integer"
          },
          "scene_name": {
            "type": "string"
          },
          "target": {
            "description": "The id of the source or scene it places.",
            "format": "uuid",
            "type": "string"
          },
          "visible": {
            "type": "boolean"
          }
        },
        "required": [
          "id",
          "scene",
          "scene_name",
          "scene_item_id",
          "index",
          "framings",
          "framing",
          "kind",
          "target",
          "name",
          "visible",
          "locked",
          "freeze_on_air",
          "clipped",
          "opacity"
        ],
        "title": "Layer",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "LayersState",
  "type": "object"
}

mediaMediaState

Brings media.changed. Lights media.control, media.speed.

Value

  • itemsmap of id → MediaPlaybackalways
    Fields of items
    • at_msintegeralwayscan be null

      When position_ms was true (Unix ms); null before it's opened.

    • duration_msintegeralwayscan be null

      The item's length, when its file says.

    • errorstringalwayscan be null

      Why it can't play, when it can't.

    • idstring (uuid)always
    • itemintegeralways

      The playing item's place in the playlist (0 is the first).

    • item_namestringalwayscan be null

      The playing item's file name.

    • itemsintegeralwayscan be null

      How many items there are (1 for a single file); null before it's opened.

    • namestringalways
    • on_airbooleanalways

      Shown on air (or about to be): only then does a playing source move on.

    • position_msintegeralways

      Milliseconds into the item at at_ms; while playing on air it moves on with the clock.

    • speednumberalways

      How fast it plays, 0.25 to 4 (1 is as the file is): while playing on air, position_ms moves on this many ms a ms.

    • stateMediaPlayState (string)always

      One of "idle" "opening" "playing" "paused" "stopped" "ended"

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Media);
var value = studio.State.Media;  // MediaState
TypeScript
await studio.subscribe("media");
const value = studio.state.media;  // MediaState
Python
await studio.subscribe(TopicType.MEDIA)
value = studio.state.media
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "at_ms": {
            "description": "When position_ms was true (Unix ms); null before it's opened.",
            "type": [
              "integer",
              "null"
            ]
          },
          "duration_ms": {
            "description": "The item's length, when its file says.",
            "type": [
              "integer",
              "null"
            ]
          },
          "error": {
            "description": "Why it can't play, when it can't.",
            "type": [
              "string",
              "null"
            ]
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "item": {
            "description": "The playing item's place in the playlist (0 is the first).",
            "type": "integer"
          },
          "item_name": {
            "description": "The playing item's file name.",
            "type": [
              "string",
              "null"
            ]
          },
          "items": {
            "description": "How many items there are (1 for a single file); null before it's opened.",
            "type": [
              "integer",
              "null"
            ]
          },
          "name": {
            "type": "string"
          },
          "on_air": {
            "description": "Shown on air (or about to be): only then does a playing source move on.",
            "type": "boolean"
          },
          "position_ms": {
            "description": "Milliseconds into the item at at_ms; while playing on air it moves on with the clock.",
            "type": "integer"
          },
          "speed": {
            "description": "How fast it plays, 0.25 to 4 (1 is as the file is): while playing on air, position_ms moves on this many ms a ms.",
            "type": "number"
          },
          "state": {
            "enum": [
              "idle",
              "opening",
              "playing",
              "paused",
              "stopped",
              "ended"
            ],
            "title": "MediaPlayState",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "state",
          "on_air",
          "position_ms",
          "at_ms",
          "duration_ms",
          "item",
          "items",
          "item_name",
          "error",
          "speed"
        ],
        "title": "MediaPlayback",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "MediaState",
  "type": "object"
}

metersMetersState

Value

  • itemsmap of id → MeterLevelsalways
    Fields of items
    • peak_dbarray of numberalwayscan be null
    • rms_dbarray of numberalwayscan be null

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Meters);
var value = studio.State.Meters;  // MetersState
TypeScript
await studio.subscribe("meters");
const value = studio.state.meters;  // MetersState
Python
await studio.subscribe(TopicType.METERS)
value = studio.state.meters
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "description": "Left and right, in dBFS; null is silence.",
        "properties": {
          "peak_db": {
            "items": {
              "type": [
                "number",
                "null"
              ]
            },
            "type": [
              "array",
              "null"
            ]
          },
          "rms_db": {
            "items": {
              "type": [
                "number",
                "null"
              ]
            },
            "type": [
              "array",
              "null"
            ]
          }
        },
        "required": [
          "peak_db",
          "rms_db"
        ],
        "title": "MeterLevels",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "MetersState",
  "type": "object"
}

ndiNdiState

Lights ndi.start, ndi.stop, ndi.toggle.

Value

  • connectionsintegeralways

    Receivers connected to it now.

    At least 0

  • namestringalwayscan be null

    The program's NDI® sender name, while on.

  • onbooleanalways

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Ndi);
var value = studio.State.Ndi;  // NdiState
TypeScript
await studio.subscribe("ndi");
const value = studio.state.ndi;  // NdiState
Python
await studio.subscribe(TopicType.NDI)
value = studio.state.ndi
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "connections": {
      "description": "Receivers connected to it now.",
      "minimum": 0,
      "type": "integer"
    },
    "name": {
      "description": "The program's NDI® sender name, while on.",
      "type": [
        "string",
        "null"
      ]
    },
    "on": {
      "type": "boolean"
    }
  },
  "required": [
    "on",
    "name",
    "connections"
  ],
  "title": "NdiState",
  "type": "object"
}

networkNetworkState

Lights network.stream_on.

Value

  • backupstringalways

    The card streams fall back to when the preferred one is unplugged, gone or without an address: none, or its key.

  • backup_namestringalwayscan be null

    The backup's name, null for none.

  • itemsmap of id → NetworkCardalways

    Every network card but the loopback, by its key (Windows' adapter GUID, elsewhere its interface name).

    Fields of items
    • addressesarray of stringalways

      Its addresses, IPv4 first.

    • namestringalways

      As the system names it: Ethernet 2 (Windows), enp6s0 (Linux), en0 (macOS).

    • streamsbooleanalways

      A stream could go out on it now: up, with an address.

    • upbooleanalways

      Its link is up.

  • preferredstringalways

    The card streams go out on: auto (the system's default network), or the chosen card's key.

  • preferred_namestringalwayscan be null

    The chosen card's name (kept while it isn't there), null for auto.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Network);
var value = studio.State.Network;  // NetworkState
TypeScript
await studio.subscribe("network");
const value = studio.state.network;  // NetworkState
Python
await studio.subscribe(TopicType.NETWORK)
value = studio.state.network
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "backup": {
      "description": "The card streams fall back to when the preferred one is unplugged, gone or without an address: none, or its key.",
      "type": "string"
    },
    "backup_name": {
      "description": "The backup's name, null for none.",
      "type": [
        "string",
        "null"
      ]
    },
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "addresses": {
            "description": "Its addresses, IPv4 first.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "name": {
            "description": "As the system names it: Ethernet 2 (Windows), enp6s0 (Linux), en0 (macOS).",
            "type": "string"
          },
          "streams": {
            "description": "A stream could go out on it now: up, with an address.",
            "type": "boolean"
          },
          "up": {
            "description": "Its link is up.",
            "type": "boolean"
          }
        },
        "required": [
          "name",
          "up",
          "addresses",
          "streams"
        ],
        "title": "NetworkCard",
        "type": "object"
      },
      "description": "Every network card but the loopback, by its key (Windows' adapter GUID, elsewhere its interface name).",
      "type": "object"
    },
    "preferred": {
      "description": "The card streams go out on: auto (the system's default network), or the chosen card's key.",
      "type": "string"
    },
    "preferred_name": {
      "description": "The chosen card's name (kept while it isn't there), null for auto.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "items",
    "preferred",
    "preferred_name",
    "backup",
    "backup_name"
  ],
  "title": "NetworkState",
  "type": "object"
}

recordRecordState

Brings record.paused, record.resumed. Lights record.start, record.stop, record.toggle, record.pause.

Value

  • droppedintegeralways

    Frames the encoder couldn't keep up with.

  • encoderstringalwayscan be null
  • pausedbooleanalways

    On while the recording is paused.

  • recordingbooleanalways
  • secondsintegeralways

    The file's length so far: paused time isn't counted.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Record);
var value = studio.State.Record;  // RecordState
TypeScript
await studio.subscribe("record");
const value = studio.state.record;  // RecordState
Python
await studio.subscribe(TopicType.RECORD)
value = studio.state.record
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "dropped": {
      "description": "Frames the encoder couldn't keep up with.",
      "type": "integer"
    },
    "encoder": {
      "type": [
        "string",
        "null"
      ]
    },
    "paused": {
      "description": "On while the recording is paused.",
      "type": "boolean"
    },
    "recording": {
      "type": "boolean"
    },
    "seconds": {
      "description": "The file's length so far: paused time isn't counted.",
      "type": "integer"
    }
  },
  "required": [
    "recording",
    "paused",
    "seconds",
    "dropped",
    "encoder"
  ],
  "title": "RecordState",
  "type": "object"
}

replayReplayState

Brings replay.started, replay.stopped, replay.saved. Lights replay.start, replay.stop, replay.toggle, replay.save.

Value

  • activebooleanalways

    On while the replay buffer runs.

  • buffered_secondsnumberalways

    How many seconds a save would hold now.

  • bytesintegeralways

    Memory it takes now.

  • last_savedstringalwayscan be null

    Where the newest replay went.

  • last_saved_at_msintegeralwayscan be null

    When it was saved (Unix ms).

  • memory_estimate_bytesintegeralwayscan be null

    Memory it takes at its full length (null while off).

  • ridesReplayRides (string)alwayscan be null

    The encode it shares: the recording's, the stream's, or its own (null while off).

    One of "recording" "stream" "own" null

  • secondsintegeralwayscan be null

    How many seconds it keeps (null while off).

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Replay);
var value = studio.State.Replay;  // ReplayState
TypeScript
await studio.subscribe("replay");
const value = studio.state.replay;  // ReplayState
Python
await studio.subscribe(TopicType.REPLAY)
value = studio.state.replay
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "active": {
      "description": "On while the replay buffer runs.",
      "type": "boolean"
    },
    "buffered_seconds": {
      "description": "How many seconds a save would hold now.",
      "type": "number"
    },
    "bytes": {
      "description": "Memory it takes now.",
      "type": "integer"
    },
    "last_saved": {
      "description": "Where the newest replay went.",
      "type": [
        "string",
        "null"
      ]
    },
    "last_saved_at_ms": {
      "description": "When it was saved (Unix ms).",
      "type": [
        "integer",
        "null"
      ]
    },
    "memory_estimate_bytes": {
      "description": "Memory it takes at its full length (null while off).",
      "type": [
        "integer",
        "null"
      ]
    },
    "rides": {
      "description": "The encode it shares: the recording's, the stream's, or its own (null while off).",
      "enum": [
        "recording",
        "stream",
        "own",
        null
      ],
      "title": "ReplayRides",
      "type": [
        "string",
        "null"
      ]
    },
    "seconds": {
      "description": "How many seconds it keeps (null while off).",
      "type": [
        "integer",
        "null"
      ]
    }
  },
  "required": [
    "active",
    "seconds",
    "buffered_seconds",
    "bytes",
    "memory_estimate_bytes",
    "rides",
    "last_saved",
    "last_saved_at_ms"
  ],
  "title": "ReplayState",
  "type": "object"
}

scenesScenesState

Brings scene.changed. Lights scene.switch, scene.next, scene.previous, vertical.pin, scene.transition_override.

Value

  • itemsmap of id → Scenealways
    Fields of items
    • idstring (uuid)always
    • indexintegeralways

      Its place in the Scenes list, from 0.

    • namestringalways
    • transitionTransitionSummaryalwayscan be null

      The scene's own transition (plays whenever it comes on air); null while the default plays.

      Fields of transition
      • duration_msintegeralways

        How long it takes; a stinger lasts as long as its video.

      • namestringalways

        Its saved name, else its type's (or effect's, or pack transition's) name.

      • reversebooleanalways

        Whether it plays backward with its pictures swapped.

      • typestringalways

        cut, fade, fade_to_color, slide, swipe, luma_wipe, move, effect, shader, pack or stinger.

  • orderarray of string (uuid)always

    The Scenes list's order, by id.

  • previewstring (uuid)alwayscan be null

    The id of the scene in preview, when Studio has one.

  • programstring (uuid)alwayscan be null

    The id of the scene on air.

  • program_namestringalwayscan be null
  • vertical_pinnedstring (uuid)alwayscan be null

    The id of the scene the vertical canvas is pinned to; null while it follows the scene on air (or there's no vertical canvas).

  • vertical_pinned_namestringalwayscan be null
  • vertical_programstring (uuid)alwayscan be null

    The id of the scene the vertical canvas shows (its pinned scene, else the one on air); null while the vertical canvas is off.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Scenes);
var value = studio.State.Scenes;  // ScenesState
TypeScript
await studio.subscribe("scenes");
const value = studio.state.scenes;  // ScenesState
Python
await studio.subscribe(TopicType.SCENES)
value = studio.state.scenes
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "index": {
            "description": "Its place in the Scenes list, from 0.",
            "type": "integer"
          },
          "name": {
            "type": "string"
          },
          "transition": {
            "additionalProperties": false,
            "description": "The scene's own transition (plays whenever it comes on air); null while the default plays.",
            "properties": {
              "duration_ms": {
                "description": "How long it takes; a stinger lasts as long as its video.",
                "type": "integer"
              },
              "name": {
                "description": "Its saved name, else its type's (or effect's, or pack transition's) name.",
                "type": "string"
              },
              "reverse": {
                "description": "Whether it plays backward with its pictures swapped.",
                "type": "boolean"
              },
              "type": {
                "description": "cut, fade, fade_to_color, slide, swipe, luma_wipe, move, effect, shader, pack or stinger.",
                "type": "string"
              }
            },
            "required": [
              "type",
              "name",
              "duration_ms",
              "reverse"
            ],
            "title": "TransitionSummary",
            "type": [
              "object",
              "null"
            ]
          }
        },
        "required": [
          "id",
          "name",
          "index",
          "transition"
        ],
        "title": "Scene",
        "type": "object"
      },
      "type": "object"
    },
    "order": {
      "description": "The Scenes list's order, by id.",
      "items": {
        "format": "uuid",
        "type": "string"
      },
      "type": "array"
    },
    "preview": {
      "description": "The id of the scene in preview, when Studio has one.",
      "format": "uuid",
      "type": [
        "string",
        "null"
      ]
    },
    "program": {
      "description": "The id of the scene on air.",
      "format": "uuid",
      "type": [
        "string",
        "null"
      ]
    },
    "program_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "vertical_pinned": {
      "description": "The id of the scene the vertical canvas is pinned to; null while it follows the scene on air (or there's no vertical canvas).",
      "format": "uuid",
      "type": [
        "string",
        "null"
      ]
    },
    "vertical_pinned_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "vertical_program": {
      "description": "The id of the scene the vertical canvas shows (its pinned scene, else the one on air); null while the vertical canvas is off.",
      "format": "uuid",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "program",
    "program_name",
    "preview",
    "vertical_program",
    "vertical_pinned",
    "vertical_pinned_name",
    "order",
    "items"
  ],
  "title": "ScenesState",
  "type": "object"
}

source_settingsSourceSettingsState

Every source with settings a controller can change: Studio's own (an Aurora, a blur box) and plugins' sources (the properties each plugin made automatable: an avatar's expressions, its camera, its outfit). Pick a source, pick a setting, then source.set (a value) or source.trigger (a trigger).

Value

  • itemsmap of id → SourceSettingsalways

    By source id.

    Fields of items
    • fromSourceSettingsFrom (string)always

      studio: a source Studio makes itself; plugin: a plugin's.

      One of "studio" "plugin"

    • idstring (uuid)always
    • loadedbooleanalways

      False until the source's plugin has loaded (its settings are empty until then).

    • namestringalways
    • pluginSourceSettingsPluginoptional

      The plugin it comes from.

      Fields of plugin
      • idstringalways
      • namestringoptional
      • versionstringoptional
    • settingsarray of SourceSettingalways

      In Inspector order.

      Fields of settings
      • defaultnumber or boolean or string or arrayoptional

        What it is when nothing is stored.

      • descriptionstringoptional
      • groupstringoptional

        The Inspector heading it's under.

      • keystringalways

        What source.set and source.trigger call it.

      • kindSourceSettingKind (string)always

        toggle: on or off (source.set true, false or "toggle"); trigger: fires an action (source.trigger), holds no value; number and integer: min to max (step: the Inspector's step); choice: one of options; color: "#rrggbb"; text: words; colors, sources, path: Studio's own sources' lists and files.

        One of "toggle" "trigger" "number" "integer" "choice" "color" "text" "colors" "sources" "path"

      • labelstringalways

        As the Inspector shows it.

      • maxnumberoptional
      • minnumberoptional
      • namestringalways

        Its name for pickers: its label, or for a slot named by its words, "<words>: <label>" ("happy: Toggle expression").

      • offeredbooleanalways

        False while it has no name of its own (an expression slot with no expression named): leave it out of pickers.

      • optionsarray of SourceSettingOptionoptional

        A choice's options.

        Fields of options
        • labelstringalways

          As the Inspector shows it.

        • valuestringalways

          What source.set takes.

      • stepnumberoptional
      • unitstringoptional

        degrees, seconds, milliseconds, db, hz, percent, fraction…

      • valuenumber or boolean or string or arrayoptional

        Its value now (none for a trigger).

    • typestringalways

      Its source type ("velum.aurora", "plugin.app.velumstudio.avatars/avatar").

    • type_namestringoptional

      The plugin's name for the source type ("Avatar").

In the SDKs

C#
await studio.SubscribeAsync(TopicType.SourceSettings);
var value = studio.State.SourceSettings;  // SourceSettingsState
TypeScript
await studio.subscribe("source_settings");
const value = studio.state.source_settings;  // SourceSettingsState
Python
await studio.subscribe(TopicType.SOURCE_SETTINGS)
value = studio.state.source_settings
JSON Schema
JSON
{
  "additionalProperties": false,
  "description": "Every source with settings a controller can change: Studio's own (an Aurora, a blur box) and plugins' sources (the properties each plugin made automatable: an avatar's expressions, its camera, its outfit). Pick a source, pick a setting, then source.set (a value) or source.trigger (a trigger).",
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "from": {
            "description": "studio: a source Studio makes itself; plugin: a plugin's.",
            "enum": [
              "studio",
              "plugin"
            ],
            "title": "SourceSettingsFrom",
            "type": "string"
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "loaded": {
            "description": "False until the source's plugin has loaded (its settings are empty until then).",
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "plugin": {
            "additionalProperties": false,
            "description": "The plugin it comes from.",
            "properties": {
              "id": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "version": {
                "type": "string"
              }
            },
            "required": [
              "id"
            ],
            "title": "SourceSettingsPlugin",
            "type": "object"
          },
          "settings": {
            "description": "In Inspector order.",
            "items": {
              "additionalProperties": false,
              "properties": {
                "default": {
                  "description": "What it is when nothing is stored.",
                  "items": {
                    "type": "string"
                  },
                  "type": [
                    "number",
                    "boolean",
                    "string",
                    "array"
                  ]
                },
                "description": {
                  "type": "string"
                },
                "group": {
                  "description": "The Inspector heading it's under.",
                  "type": "string"
                },
                "key": {
                  "description": "What source.set and source.trigger call it.",
                  "type": "string"
                },
                "kind": {
                  "description": "toggle: on or off (source.set true, false or \"toggle\"); trigger: fires an action (source.trigger), holds no value; number and integer: min to max (step: the Inspector's step); choice: one of options; color: \"#rrggbb\"; text: words; colors, sources, path: Studio's own sources' lists and files.",
                  "enum": [
                    "toggle",
                    "trigger",
                    "number",
                    "integer",
                    "choice",
                    "color",
                    "text",
                    "colors",
                    "sources",
                    "path"
                  ],
                  "title": "SourceSettingKind",
                  "type": "string"
                },
                "label": {
                  "description": "As the Inspector shows it.",
                  "type": "string"
                },
                "max": {
                  "type": "number"
                },
                "min": {
                  "type": "number"
                },
                "name": {
                  "description": "Its name for pickers: its label, or for a slot named by its words, \"<words>: <label>\" (\"happy: Toggle expression\").",
                  "type": "string"
                },
                "offered": {
                  "description": "False while it has no name of its own (an expression slot with no expression named): leave it out of pickers.",
                  "type": "boolean"
                },
                "options": {
                  "description": "A choice's options.",
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "label": {
                        "description": "As the Inspector shows it.",
                        "type": "string"
                      },
                      "value": {
                        "description": "What source.set takes.",
                        "type": "string"
                      }
                    },
                    "required": [
                      "value",
                      "label"
                    ],
                    "title": "SourceSettingOption",
                    "type": "object"
                  },
                  "type": "array"
                },
                "step": {
                  "type": "number"
                },
                "unit": {
                  "description": "degrees, seconds, milliseconds, db, hz, percent, fraction…",
                  "type": "string"
                },
                "value": {
                  "description": "Its value now (none for a trigger).",
                  "items": {
                    "type": "string"
                  },
                  "type": [
                    "number",
                    "boolean",
                    "string",
                    "array"
                  ]
                }
              },
              "required": [
                "key",
                "name",
                "label",
                "kind",
                "offered"
              ],
              "title": "SourceSetting",
              "type": "object"
            },
            "type": "array"
          },
          "type": {
            "description": "Its source type (\"velum.aurora\", \"plugin.app.velumstudio.avatars/avatar\").",
            "type": "string"
          },
          "type_name": {
            "description": "The plugin's name for the source type (\"Avatar\").",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "type",
          "from",
          "loaded",
          "settings"
        ],
        "title": "SourceSettings",
        "type": "object"
      },
      "description": "By source id.",
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "SourceSettingsState",
  "type": "object"
}

sourcesSourcesState

Lights source.set, text.set, mirror.show.

Value

  • itemsmap of id → Sourcealways
    Fields of items
    • has_audiobooleanalways
    • idstring (uuid)always
    • namestringalways
    • settingsobjectoptional

      Its settings now, by key: a source Studio makes itself (an Aurora, a blur box; source_settings in catalog.list describes each type's) or a plugin's source (the values of the settings its plugin made automatable, once the plugin has loaded; plugin_settings in catalog.list). The source_settings topic names and describes them.

    • showsstring (uuid)optionalcan be null

      The id of the source a Mirror shows, or null (Mirrors only).

    • textstringoptional

      What a text source says (text sources only).

    • typestringalways

      The source's type, such as velum.text.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Sources);
var value = studio.State.Sources;  // SourcesState
TypeScript
await studio.subscribe("sources");
const value = studio.state.sources;  // SourcesState
Python
await studio.subscribe(TopicType.SOURCES)
value = studio.state.sources
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "has_audio": {
            "type": "boolean"
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "settings": {
            "description": "Its settings now, by key: a source Studio makes itself (an Aurora, a blur box; source_settings in catalog.list describes each type's) or a plugin's source (the values of the settings its plugin made automatable, once the plugin has loaded; plugin_settings in catalog.list). The source_settings topic names and describes them.",
            "type": "object"
          },
          "shows": {
            "description": "The id of the source a Mirror shows, or null (Mirrors only).",
            "format": "uuid",
            "type": [
              "string",
              "null"
            ]
          },
          "text": {
            "description": "What a text source says (text sources only).",
            "type": "string"
          },
          "type": {
            "description": "The source's type, such as velum.text.",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "type",
          "has_audio"
        ],
        "title": "Source",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "SourcesState",
  "type": "object"
}

statsStatsState

Lights stats.show.

Value

  • fpsnumberalwayscan be null

    The canvas's frame rate.

  • liveLiveStatsalwayscan be null
  • outputOutputStatsalways
  • previewPreviewStatsalways
  • recordRecordStatsalwayscan be null
  • renderRenderStatsalwayscan be null

    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.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Stats);
var value = studio.State.Stats;  // StatsState
TypeScript
await studio.subscribe("stats");
const value = studio.state.stats;  // StatsState
Python
await studio.subscribe(TopicType.STATS)
value = studio.state.stats
JSON Schema
JSON
{
  "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"
}

streamStreamState

Brings captions.sent. Lights stream.golive, stream.stop, stream.viewers.

Value

  • destinationstringalwayscan be null

    The id of the destination it's going to.

  • destination_namestringalwayscan be null
  • livebooleanalways

    On while live; connecting and reconnecting count.

  • secondsintegeralways

    How long it's been live.

  • stateStreamStatus (string)always

    One of "offline" "delayed" "connecting" "live" "reconnecting" "stopping" "refused" "error"

  • viewersmap of id → integeralways

    Viewers by platform, while live.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Stream);
var value = studio.State.Stream;  // StreamState
TypeScript
await studio.subscribe("stream");
const value = studio.state.stream;  // StreamState
Python
await studio.subscribe(TopicType.STREAM)
value = studio.state.stream
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "destination": {
      "description": "The id of the destination it's going to.",
      "type": [
        "string",
        "null"
      ]
    },
    "destination_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "live": {
      "description": "On while live; connecting and reconnecting count.",
      "type": "boolean"
    },
    "seconds": {
      "description": "How long it's been live.",
      "type": "integer"
    },
    "state": {
      "enum": [
        "offline",
        "delayed",
        "connecting",
        "live",
        "reconnecting",
        "stopping",
        "refused",
        "error"
      ],
      "title": "StreamStatus",
      "type": "string"
    },
    "viewers": {
      "additionalProperties": {
        "type": "integer"
      },
      "description": "Viewers by platform, while live.",
      "type": "object"
    }
  },
  "required": [
    "live",
    "state",
    "destination",
    "destination_name",
    "seconds",
    "viewers"
  ],
  "title": "StreamState",
  "type": "object"
}

stream_infoStreamInfoState

Lights streaminfo.apply.

Value

  • categoryStreamCategoryalways
  • tagsarray of stringalways
  • titlestringalways

In the SDKs

C#
await studio.SubscribeAsync(TopicType.StreamInfo);
var value = studio.State.StreamInfo;  // StreamInfoState
TypeScript
await studio.subscribe("stream_info");
const value = studio.state.stream_info;  // StreamInfoState
Python
await studio.subscribe(TopicType.STREAM_INFO)
value = studio.state.stream_info
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "category": {
      "additionalProperties": false,
      "properties": {
        "art": {
          "description": "A link to its box art, when known.",
          "type": "string"
        },
        "game": {
          "description": "Known to be a game.",
          "type": "boolean"
        },
        "name": {
          "type": "string"
        },
        "slug": {
          "description": "Its Velora slug, when it has one.",
          "type": "string"
        }
      },
      "required": [
        "name"
      ],
      "title": "StreamCategory",
      "type": "object"
    },
    "tags": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "title": {
      "type": "string"
    }
  },
  "required": [
    "title",
    "category",
    "tags"
  ],
  "title": "StreamInfoState",
  "type": "object"
}

themeThemeState

Value

  • appearanceThemeAppearance (string)alwayscan be null

    dark or light.

    One of "dark" "light" null

  • idstringalwayscan be null

    The active theme's id (studio-dark, studio-light, or one the person made or installed).

  • namestringalwayscan be null
  • revisionintegeralways

    Goes up each time the theme changes (another theme, a saved edit, a color dragged in Theme Studio).

  • tokensmap of id → string or numberalways

    Every token by name (docs/THEMING.md), resolved: colors as #rrggbbaa, sizes in pixels and weights as numbers, font.family as text.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Theme);
var value = studio.State.Theme;  // ThemeState
TypeScript
await studio.subscribe("theme");
const value = studio.state.theme;  // ThemeState
Python
await studio.subscribe(TopicType.THEME)
value = studio.state.theme
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "appearance": {
      "description": "dark or light.",
      "enum": [
        "dark",
        "light",
        null
      ],
      "title": "ThemeAppearance",
      "type": [
        "string",
        "null"
      ]
    },
    "id": {
      "description": "The active theme's id (studio-dark, studio-light, or one the person made or installed).",
      "type": [
        "string",
        "null"
      ]
    },
    "name": {
      "type": [
        "string",
        "null"
      ]
    },
    "revision": {
      "description": "Goes up each time the theme changes (another theme, a saved edit, a color dragged in Theme Studio).",
      "type": "integer"
    },
    "tokens": {
      "additionalProperties": {
        "type": [
          "string",
          "number"
        ]
      },
      "description": "Every token by name (docs/THEMING.md), resolved: colors as #rrggbbaa, sizes in pixels and weights as numbers, font.family as text.",
      "type": "object"
    }
  },
  "required": [
    "id",
    "name",
    "appearance",
    "revision",
    "tokens"
  ],
  "title": "ThemeState",
  "type": "object"
}

transitionsTransitionsState

Lights transition.set, transition.wait, studio.mode, scene.preview, studio.take.

Value

  • default_duration_msintegeralwayscan be null
  • default_namestringalwayscan be null
  • default_reversebooleanalways

    Whether it plays backward with its pictures swapped.

  • default_typestringalwayscan be null

    The type a scene switch plays unless the incoming scene has its own.

  • errorstringalwayscan be null

    Why the last stinger or custom shader couldn't play.

  • in_progressbooleanalways

    On while a transition plays.

  • packarray of PackTransitionalways

    The transition pack (gl-transitions): each one's word for transition.set, its name, and whether it can be a layer's show or hide.

    Fields of pack
    • layersbooleanalways

      Whether it can be a layer's show or hide (some paint a color of their own, which would fill a layer's box).

    • namestringalways
    • wordstringalways

      Its word for transition.set and scene.transition_override (pack:cube).

  • playingarray of TransitionPlayingalways

    The transitions playing, one per canvas.

    Fields of playing
    • canvasstring (uuid)always

      The canvas it plays on.

    • duration_msnumberalways

      How long it plays in all (a stinger: its video's length once known).

    • fromstring (uuid)always

      The scene it leaves (the oldest still on screen when one plays underneath).

    • namestringalways
    • progressnumberalways

      0 to 1.

    • tostring (uuid)always

      The scene it goes to.

    • typestringalways
  • previewstring (uuid)alwayscan be null

    The id of the scene in preview, in studio mode.

  • preview_namestringalwayscan be null
  • savedarray of TransitionSummaryalways

    The transitions saved by name.

    Fields of saved
    • duration_msintegeralways

      How long it takes; a stinger lasts as long as its video.

    • namestringalways

      Its saved name, else its type's (or effect's, or pack transition's) name.

    • reversebooleanalways

      Whether it plays backward with its pictures swapped.

    • typestringalways

      cut, fade, fade_to_color, slide, swipe, luma_wipe, move, effect, shader, pack or stinger.

  • studio_modebooleanalways

    On while studio mode is on (there's a preview scene).

  • typesarray of stringalways

    The types a transition can be picked by (each pack transition is picked by its own word, from pack).

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Transitions);
var value = studio.State.Transitions;  // TransitionsState
TypeScript
await studio.subscribe("transitions");
const value = studio.state.transitions;  // TransitionsState
Python
await studio.subscribe(TopicType.TRANSITIONS)
value = studio.state.transitions
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "default_duration_ms": {
      "type": [
        "integer",
        "null"
      ]
    },
    "default_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "default_reverse": {
      "description": "Whether it plays backward with its pictures swapped.",
      "type": "boolean"
    },
    "default_type": {
      "description": "The type a scene switch plays unless the incoming scene has its own.",
      "type": [
        "string",
        "null"
      ]
    },
    "error": {
      "description": "Why the last stinger or custom shader couldn't play.",
      "type": [
        "string",
        "null"
      ]
    },
    "in_progress": {
      "description": "On while a transition plays.",
      "type": "boolean"
    },
    "pack": {
      "description": "The transition pack (gl-transitions): each one's word for transition.set, its name, and whether it can be a layer's show or hide.",
      "items": {
        "additionalProperties": false,
        "properties": {
          "layers": {
            "description": "Whether it can be a layer's show or hide (some paint a color of their own, which would fill a layer's box).",
            "type": "boolean"
          },
          "name": {
            "type": "string"
          },
          "word": {
            "description": "Its word for transition.set and scene.transition_override (pack:cube).",
            "type": "string"
          }
        },
        "required": [
          "word",
          "name",
          "layers"
        ],
        "title": "PackTransition",
        "type": "object"
      },
      "type": "array"
    },
    "playing": {
      "description": "The transitions playing, one per canvas.",
      "items": {
        "additionalProperties": false,
        "properties": {
          "canvas": {
            "description": "The canvas it plays on.",
            "format": "uuid",
            "type": "string"
          },
          "duration_ms": {
            "description": "How long it plays in all (a stinger: its video's length once known).",
            "type": "number"
          },
          "from": {
            "description": "The scene it leaves (the oldest still on screen when one plays underneath).",
            "format": "uuid",
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "progress": {
            "description": "0 to 1.",
            "type": "number"
          },
          "to": {
            "description": "The scene it goes to.",
            "format": "uuid",
            "type": "string"
          },
          "type": {
            "type": "string"
          }
        },
        "required": [
          "canvas",
          "from",
          "to",
          "type",
          "name",
          "progress",
          "duration_ms"
        ],
        "title": "TransitionPlaying",
        "type": "object"
      },
      "type": "array"
    },
    "preview": {
      "description": "The id of the scene in preview, in studio mode.",
      "format": "uuid",
      "type": [
        "string",
        "null"
      ]
    },
    "preview_name": {
      "type": [
        "string",
        "null"
      ]
    },
    "saved": {
      "description": "The transitions saved by name.",
      "items": {
        "additionalProperties": false,
        "properties": {
          "duration_ms": {
            "description": "How long it takes; a stinger lasts as long as its video.",
            "type": "integer"
          },
          "name": {
            "description": "Its saved name, else its type's (or effect's, or pack transition's) name.",
            "type": "string"
          },
          "reverse": {
            "description": "Whether it plays backward with its pictures swapped.",
            "type": "boolean"
          },
          "type": {
            "description": "cut, fade, fade_to_color, slide, swipe, luma_wipe, move, effect, shader, pack or stinger.",
            "type": "string"
          }
        },
        "required": [
          "type",
          "name",
          "duration_ms",
          "reverse"
        ],
        "title": "TransitionSummary",
        "type": "object"
      },
      "type": "array"
    },
    "studio_mode": {
      "description": "On while studio mode is on (there's a preview scene).",
      "type": "boolean"
    },
    "types": {
      "description": "The types a transition can be picked by (each pack transition is picked by its own word, from pack).",
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "required": [
    "default_type",
    "default_name",
    "default_duration_ms",
    "default_reverse",
    "types",
    "pack",
    "saved",
    "studio_mode",
    "preview",
    "preview_name",
    "in_progress",
    "playing",
    "error"
  ],
  "title": "TransitionsState",
  "type": "object"
}

updateUpdateState

Lights update.check, update.install.

Value

  • availablebooleanalways

    On while an update is on offer (available, downloading or ready).

  • channelstringalwayscan be null

    The update channel: stable, beta or internal.

  • current_versionstringalwayscan be null

    The running Studio's version.

  • datestringalwayscan be null

    Its release date.

  • downloaded_bytesintegeralways
  • errorstringalwayscan be null

    Why the last check or download failed.

  • install_pendingbooleanalways

    Update now was pressed while live, recording or keeping a replay buffer: it starts once that ends.

  • last_checked_msintegeralwayscan be null

    When the channel was last asked (Unix ms).

  • lateststringalwayscan be null

    The newest version on the channel, once checked.

  • notesstringalwayscan be null

    Its release notes (Markdown).

  • progressnumberalwayscan be null

    0 to 1 while downloading; 1 once ready.

  • sizeintegeralwayscan be null

    Its download's size in bytes (null when the package manager updates Studio).

  • stateUpdateStatus (string)always

    idle (nothing on offer, or not checked yet), checking, available, downloading, ready (downloaded and verified: Studio restarts into it when asked) or error.

    One of "idle" "checking" "available" "downloading" "ready" "error"

  • updates_itselfbooleanalways

    This copy is updated by its package manager (Flatpak); Studio only says there's an update.

  • versionstringalwayscan be null

    The version on offer.

  • waiting_forstringalwayscan be null

    What a pending install waits for (live, recording, replay buffer).

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Update);
var value = studio.State.Update;  // UpdateState
TypeScript
await studio.subscribe("update");
const value = studio.state.update;  // UpdateState
Python
await studio.subscribe(TopicType.UPDATE)
value = studio.state.update
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "available": {
      "description": "On while an update is on offer (available, downloading or ready).",
      "type": "boolean"
    },
    "channel": {
      "description": "The update channel: stable, beta or internal.",
      "type": [
        "string",
        "null"
      ]
    },
    "current_version": {
      "description": "The running Studio's version.",
      "type": [
        "string",
        "null"
      ]
    },
    "date": {
      "description": "Its release date.",
      "type": [
        "string",
        "null"
      ]
    },
    "downloaded_bytes": {
      "type": "integer"
    },
    "error": {
      "description": "Why the last check or download failed.",
      "type": [
        "string",
        "null"
      ]
    },
    "install_pending": {
      "description": "Update now was pressed while live, recording or keeping a replay buffer: it starts once that ends.",
      "type": "boolean"
    },
    "last_checked_ms": {
      "description": "When the channel was last asked (Unix ms).",
      "type": [
        "integer",
        "null"
      ]
    },
    "latest": {
      "description": "The newest version on the channel, once checked.",
      "type": [
        "string",
        "null"
      ]
    },
    "notes": {
      "description": "Its release notes (Markdown).",
      "type": [
        "string",
        "null"
      ]
    },
    "progress": {
      "description": "0 to 1 while downloading; 1 once ready.",
      "type": [
        "number",
        "null"
      ]
    },
    "size": {
      "description": "Its download's size in bytes (null when the package manager updates Studio).",
      "type": [
        "integer",
        "null"
      ]
    },
    "state": {
      "description": "idle (nothing on offer, or not checked yet), checking, available, downloading, ready (downloaded and verified: Studio restarts into it when asked) or error.",
      "enum": [
        "idle",
        "checking",
        "available",
        "downloading",
        "ready",
        "error"
      ],
      "title": "UpdateStatus",
      "type": "string"
    },
    "updates_itself": {
      "description": "This copy is updated by its package manager (Flatpak); Studio only says there's an update.",
      "type": "boolean"
    },
    "version": {
      "description": "The version on offer.",
      "type": [
        "string",
        "null"
      ]
    },
    "waiting_for": {
      "description": "What a pending install waits for (live, recording, replay buffer).",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "state",
    "available",
    "current_version",
    "channel",
    "latest",
    "version",
    "date",
    "notes",
    "size",
    "progress",
    "downloaded_bytes",
    "install_pending",
    "waiting_for",
    "updates_itself",
    "error",
    "last_checked_ms"
  ],
  "title": "UpdateState",
  "type": "object"
}

variablesVariablesState

Lights variable.set.

Value

  • itemsmap of id → Variablealways

    Each automation variable by name (what {var:name} shows in a text layer).

    Fields of items
    • valuestringalways

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Variables);
var value = studio.State.Variables;  // VariablesState
TypeScript
await studio.subscribe("variables");
const value = studio.state.variables;  // VariablesState
Python
await studio.subscribe(TopicType.VARIABLES)
value = studio.state.variables
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "value": {
            "type": "string"
          }
        },
        "required": [
          "value"
        ],
        "title": "Variable",
        "type": "object"
      },
      "description": "Each automation variable by name (what {var:name} shows in a text layer).",
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "VariablesState",
  "type": "object"
}

vcamVcamState

Lights vcam.start, vcam.stop, vcam.toggle, vcam.source.

Value

  • devicestringalwayscan be null

    The virtual camera device, while on.

  • onbooleanalways
  • scenestring (uuid)alwayscan be null

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

  • scene_namestringalwayscan be null

    That scene's name.

  • sourceVcamSource (string)always

    What it sends: on_air (what's on air, the default) or scene (one scene, drawn off air whatever is live). Kept with the collection, on or off.

    One of "on_air" "scene"

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Vcam);
var value = studio.State.Vcam;  // VcamState
TypeScript
await studio.subscribe("vcam");
const value = studio.state.vcam;  // VcamState
Python
await studio.subscribe(TopicType.VCAM)
value = studio.state.vcam
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "device": {
      "description": "The virtual camera device, while on.",
      "type": [
        "string",
        "null"
      ]
    },
    "on": {
      "type": "boolean"
    },
    "scene": {
      "description": "The id of the scene it sends; null while it sends what's on air.",
      "format": "uuid",
      "type": [
        "string",
        "null"
      ]
    },
    "scene_name": {
      "description": "That scene's name.",
      "type": [
        "string",
        "null"
      ]
    },
    "source": {
      "description": "What it sends: on_air (what's on air, the default) or scene (one scene, drawn off air whatever is live). Kept with the collection, on or off.",
      "enum": [
        "on_air",
        "scene"
      ],
      "title": "VcamSource",
      "type": "string"
    }
  },
  "required": [
    "on",
    "device",
    "source",
    "scene",
    "scene_name"
  ],
  "title": "VcamState",
  "type": "object"
}

veloqVeloqState

Lights veloq.transitions, veloq.sliders.

Value

  • has_stingerbooleanalways

    The collection has a stinger (its sound plays through the Transitions channel).

  • mixerViewerMixeralways

    The viewer's mixer as Velora's player builds it from those tracks.

    Fields of mixer
    • groupsarray of ViewerMixerGroupalways

      Then a header per group, in the order groups first appear.

      Fields of groups
    • loosearray of ViewerMixerRowalways

      Sliders with no group, first.

    • shownbooleanalways

      Velora shows the mixer (two or more sliders).

    • silent_slidersintegeralways

      Sliders that move nothing (Editor+ stems).

    • slidersintegeralways
    • vodarray of stringalways

      The tracks Velora's VOD keeps, by label.

  • not_sentarray of string (uuid)always

    Sources that never leave Studio.

  • slider_limitintegeralways

    How many there are (8).

  • sliders_usedintegeralways

    Viewer sliders taken by sources and sends.

  • tracksarray of VeloqTrackalways

    The audio tracks a VELoQ Go Live sends, in order (the stream mix first).

    Fields of tracks
    • in_vodbooleanalways
    • kindVeloqTrackKind (string)always

      One of "program" "source" "send" "hidden" "other" "stem"

    • labelstringalwayscan be null

      What viewers read.

    • namestringalways

      Its name on the wire.

    • sourcesarray of string (uuid)alwayscan be null

      The sources it carries; null for the stream mix (Studio's track 1).

  • transitionsVeloqVisibility (string)always

    Where stinger sounds go for viewers.

    One of "public" "public_drop_vod" "hidden_keep_vod" "hidden_drop_vod" "not_sent"

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Veloq);
var value = studio.State.Veloq;  // VeloqState
TypeScript
await studio.subscribe("veloq");
const value = studio.state.veloq;  // VeloqState
Python
await studio.subscribe(TopicType.VELOQ)
value = studio.state.veloq
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "has_stinger": {
      "description": "The collection has a stinger (its sound plays through the Transitions channel).",
      "type": "boolean"
    },
    "mixer": {
      "additionalProperties": false,
      "description": "The viewer's mixer as Velora's player builds it from those tracks.",
      "properties": {
        "groups": {
          "description": "Then a header per group, in the order groups first appear.",
          "items": {
            "additionalProperties": false,
            "properties": {
              "id": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "rows": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "in_vod": {
                      "description": "Velora's VOD keeps it.",
                      "type": "boolean"
                    },
                    "kind": {
                      "enum": [
                        "program",
                        "source",
                        "send",
                        "hidden",
                        "other",
                        "stem"
                      ],
                      "title": "VeloqTrackKind",
                      "type": "string"
                    },
                    "label": {
                      "description": "What viewers read.",
                      "type": "string"
                    },
                    "muted": {
                      "description": "It starts muted.",
                      "type": "boolean"
                    },
                    "sources": {
                      "description": "The sources it carries.",
                      "items": {
                        "format": "uuid",
                        "type": "string"
                      },
                      "type": "array"
                    },
                    "track": {
                      "description": "The track's name on the wire.",
                      "type": "string"
                    },
                    "volume": {
                      "description": "Where the viewer's slider starts (0 to 1).",
                      "type": "number"
                    }
                  },
                  "required": [
                    "track",
                    "label",
                    "kind",
                    "in_vod",
                    "volume",
                    "muted",
                    "sources"
                  ],
                  "title": "ViewerMixerRow",
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "id",
              "name",
              "rows"
            ],
            "title": "ViewerMixerGroup",
            "type": "object"
          },
          "type": "array"
        },
        "loose": {
          "description": "Sliders with no group, first.",
          "items": {
            "additionalProperties": false,
            "properties": {
              "in_vod": {
                "description": "Velora's VOD keeps it.",
                "type": "boolean"
              },
              "kind": {
                "enum": [
                  "program",
                  "source",
                  "send",
                  "hidden",
                  "other",
                  "stem"
                ],
                "title": "VeloqTrackKind",
                "type": "string"
              },
              "label": {
                "description": "What viewers read.",
                "type": "string"
              },
              "muted": {
                "description": "It starts muted.",
                "type": "boolean"
              },
              "sources": {
                "description": "The sources it carries.",
                "items": {
                  "format": "uuid",
                  "type": "string"
                },
                "type": "array"
              },
              "track": {
                "description": "The track's name on the wire.",
                "type": "string"
              },
              "volume": {
                "description": "Where the viewer's slider starts (0 to 1).",
                "type": "number"
              }
            },
            "required": [
              "track",
              "label",
              "kind",
              "in_vod",
              "volume",
              "muted",
              "sources"
            ],
            "title": "ViewerMixerRow",
            "type": "object"
          },
          "type": "array"
        },
        "shown": {
          "description": "Velora shows the mixer (two or more sliders).",
          "type": "boolean"
        },
        "silent_sliders": {
          "description": "Sliders that move nothing (Editor+ stems).",
          "type": "integer"
        },
        "sliders": {
          "type": "integer"
        },
        "vod": {
          "description": "The tracks Velora's VOD keeps, by label.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "shown",
        "loose",
        "groups",
        "sliders",
        "silent_sliders",
        "vod"
      ],
      "title": "ViewerMixer",
      "type": "object"
    },
    "not_sent": {
      "description": "Sources that never leave Studio.",
      "items": {
        "format": "uuid",
        "type": "string"
      },
      "type": "array"
    },
    "slider_limit": {
      "description": "How many there are (8).",
      "type": "integer"
    },
    "sliders_used": {
      "description": "Viewer sliders taken by sources and sends.",
      "type": "integer"
    },
    "tracks": {
      "description": "The audio tracks a VELoQ Go Live sends, in order (the stream mix first).",
      "items": {
        "additionalProperties": false,
        "properties": {
          "in_vod": {
            "type": "boolean"
          },
          "kind": {
            "enum": [
              "program",
              "source",
              "send",
              "hidden",
              "other",
              "stem"
            ],
            "title": "VeloqTrackKind",
            "type": "string"
          },
          "label": {
            "description": "What viewers read.",
            "type": [
              "string",
              "null"
            ]
          },
          "name": {
            "description": "Its name on the wire.",
            "type": "string"
          },
          "sources": {
            "description": "The sources it carries; null for the stream mix (Studio's track 1).",
            "items": {
              "format": "uuid",
              "type": "string"
            },
            "type": [
              "array",
              "null"
            ]
          }
        },
        "required": [
          "name",
          "kind",
          "label",
          "in_vod",
          "sources"
        ],
        "title": "VeloqTrack",
        "type": "object"
      },
      "type": "array"
    },
    "transitions": {
      "description": "Where stinger sounds go for viewers.",
      "enum": [
        "public",
        "public_drop_vod",
        "hidden_keep_vod",
        "hidden_drop_vod",
        "not_sent"
      ],
      "title": "VeloqVisibility",
      "type": "string"
    }
  },
  "required": [
    "tracks",
    "mixer",
    "sliders_used",
    "slider_limit",
    "not_sent",
    "has_stinger",
    "transitions"
  ],
  "title": "VeloqState",
  "type": "object"
}

webWebState

Brings web.changed.

Value

  • itemsmap of id → WebPagealways
    Fields of items
    • attemptsintegeralways

      Failed tries in a row.

    • can_reloadbooleanalways

      Whether it can be loaded again now (its page is open).

    • codestringalwayscan be null

      Why it failed: connection_refused, cannot_connect, name_not_resolved, timed_out, offline, connection_reset, unreachable, certificate, bad_response, file_not_found, http_error, other, or engine (the web engine itself couldn't run); null unless failed.

    • http_statusintegeralwayscan be null

      The main document's HTTP status, when that's why it failed.

    • idstring (uuid)always
    • messagestringalwayscan be null

      Why it failed, in plain words ("Can't reach localhost:3000 (connection refused)"); null unless failed.

    • namestringalways
    • retry_at_msintegeralwayscan be null

      When the next try starts (Unix ms); null while one is under way or nothing failed.

    • stateWebPageState (string)always

      idle (not in use), loading, ok, or failed: then it's see-through on air and tried again by itself (2 s, 5 s, 10 s, then every 30 s).

      One of "idle" "loading" "ok" "failed"

    • urlstringalwayscan be null

      The address it's loading or that failed.

In the SDKs

C#
await studio.SubscribeAsync(TopicType.Web);
var value = studio.State.Web;  // WebState
TypeScript
await studio.subscribe("web");
const value = studio.state.web;  // WebState
Python
await studio.subscribe(TopicType.WEB)
value = studio.state.web
JSON Schema
JSON
{
  "additionalProperties": false,
  "properties": {
    "items": {
      "additionalProperties": {
        "additionalProperties": false,
        "properties": {
          "attempts": {
            "description": "Failed tries in a row.",
            "type": "integer"
          },
          "can_reload": {
            "description": "Whether it can be loaded again now (its page is open).",
            "type": "boolean"
          },
          "code": {
            "description": "Why it failed: connection_refused, cannot_connect, name_not_resolved, timed_out, offline, connection_reset, unreachable, certificate, bad_response, file_not_found, http_error, other, or engine (the web engine itself couldn't run); null unless failed.",
            "type": [
              "string",
              "null"
            ]
          },
          "http_status": {
            "description": "The main document's HTTP status, when that's why it failed.",
            "type": [
              "integer",
              "null"
            ]
          },
          "id": {
            "format": "uuid",
            "type": "string"
          },
          "message": {
            "description": "Why it failed, in plain words (\"Can't reach localhost:3000 (connection refused)\"); null unless failed.",
            "type": [
              "string",
              "null"
            ]
          },
          "name": {
            "type": "string"
          },
          "retry_at_ms": {
            "description": "When the next try starts (Unix ms); null while one is under way or nothing failed.",
            "type": [
              "integer",
              "null"
            ]
          },
          "state": {
            "description": "idle (not in use), loading, ok, or failed: then it's see-through on air and tried again by itself (2 s, 5 s, 10 s, then every 30 s).",
            "enum": [
              "idle",
              "loading",
              "ok",
              "failed"
            ],
            "title": "WebPageState",
            "type": "string"
          },
          "url": {
            "description": "The address it's loading or that failed.",
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "id",
          "name",
          "state",
          "code",
          "message",
          "url",
          "http_status",
          "retry_at_ms",
          "attempts",
          "can_reload"
        ],
        "title": "WebPage",
        "type": "object"
      },
      "type": "object"
    }
  },
  "required": [
    "items"
  ],
  "title": "WebState",
  "type": "object"
}

to open · ↑ ↓ to move · Esc to close