OBS direkt steuern mit ObsSendRaw

Streamer.bot bringt fertige OBS-Sub-Actions mit: Szene wechseln, Quelle ein- und ausblenden, Filter togglen. Sobald du aber etwas brauchst, das diese Bausteine nicht abdecken, etwa die Settings einer Quelle live ändern oder die komplette Liste der Szenenelemente abfragen, sendest du den obs-websocket-Request direkt aus C#. Genau dafür ist CPH.ObsSendRaw da.

Der Request-Name und die Feldstruktur kommen unverändert aus dem obs-websocket-Protokoll. Streamer.bot reicht sie nur durch. Die offizielle Protokoll-Referenz ist deine Hauptquelle für Request-Namen und Felder.

Doku: docs.streamer.bot, ObsSendRaw und obs-websocket Protocol Requests

Die Signatur

// verifiziert gegen docs.streamer.bot
public string ObsSendRaw(string requestType, string data, int connection = 0)

requestType: der exakte obs-websocket-Request-Name, zum Beispiel SetInputSettings oder GetSceneItemList. Groß- und Kleinschreibung sind relevant.
data: ein JSON-String, der die Request-Felder enthält. Kein Objekt, sondern fertig serialisiertes JSON.
connection: der Index der obs-websocket-Verbindung in Streamer.bot. Bei genau einer Verbindung ist das 0, der Standardwert.
Rückgabe: ein JSON-String mit der Antwort von OBS. Den parst du mit JObject.Parse.

Generics und Typen im Fließtext stehen ab hier immer in Backticks, etwa JObject.Parse oder DeserializeObject<T>, weil die spitzen Klammern sonst den MDX-Build brechen.

Beispiel: Text-Source-Inhalt setzen

Wir setzen den Text einer Text-Quelle (GDI+ oder FreeType 2) über den Request SetInputSettings. Den anzuzeigenden Text bauen wir sauber per JsonConvert.SerializeObject zusammen, damit Backslashes, Anführungszeichen und Umlaute korrekt escaped werden. Niemals den JSON-String von Hand zusammenkleben.

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public class CPHInline {
  public bool Execute() {
    // Name der Text-Quelle in OBS und der neue Inhalt
    string inputName = "ChatGoal";
    string neuerText = "Nächstes Ziel: 50 Follower! 🎯";

    // data als Objekt bauen und serialisieren, statt von Hand JSON zu tippen.
    // SetInputSettings erwartet: inputName + inputSettings (+ optional overlay).
    var payload = new {
      inputName = inputName,
      inputSettings = new { text = neuerText },
      overlay = true
    };
    string data = JsonConvert.SerializeObject(payload);

    string requestType = "SetInputSettings";

    // connection 0 = erste obs-websocket-Verbindung
    string antwort = CPH.ObsSendRaw(requestType, data, 0);

    // Antwort ist ein JSON-String. Mit JObject.Parse auslesen.
    if (string.IsNullOrEmpty(antwort)) {
      CPH.LogWarn($"ObsSendRaw lieferte keine Antwort. Verbindung 0 verbunden?");
      return false;
    }

    JObject result = JObject.Parse(antwort);
    CPH.LogInfo($"OBS-Antwort: {result.ToString()}");

    return true;
  }
}

Der Trick ist das anonyme Objekt mit JsonConvert.SerializeObject. Es liefert garantiert gültiges JSON, auch wenn der Text Sonderzeichen oder Emojis enthält. Der overlay-Schalter sorgt dafür, dass nur das text-Feld überschrieben wird und die übrigen Settings der Quelle erhalten bleiben.

Beispiel: Antwort auslesen

Manche Requests liefern Nutzdaten zurück, etwa GetSceneItemList. Die Antwort steckt als verschachteltes JSON im Rückgabestring. Du navigierst mit den Feldnamen aus der obs-websocket-Doku hinein.

using Newtonsoft.Json.Linq;

public class CPHInline {
  public bool Execute() {
    var payload = new { sceneName = "Gaming" };
    string data = Newtonsoft.Json.JsonConvert.SerializeObject(payload);

    string antwort = CPH.ObsSendRaw("GetSceneItemList", data, 0);
    if (string.IsNullOrEmpty(antwort)) {
      CPH.LogWarn("Keine Antwort von OBS. obs-websocket verbunden?");
      return false;
    }

    JObject result = JObject.Parse(antwort);

    // Das Antwort-Objekt enthält ein Array sceneItems.
    JArray items = (JArray)result["sceneItems"];
    if (items == null) {
      CPH.LogWarn("Feld 'sceneItems' fehlt. Request-Name oder Feldname prüfen.");
      return false;
    }

    foreach (var item in items) {
      string name = item["sourceName"]?.ToString() ?? "unbekannt";
      CPH.LogInfo($"Szenenelement: {name}");
    }

    return true;
  }
}

Welche Felder die Antwort eines Requests genau enthält, steht in der obs-websocket Protocol-Referenz. Prüfe im Zweifel zuerst mit CPH.LogInfo($"{result.ToString()}"), wie die echte Antwort aussieht, bevor du auf einzelne Felder zugreifst.

Häufige Fallen

Falscher connection-Index: Mit 0 ist die erste obs-websocket-Verbindung gemeint. Hast du mehrere Verbindungen konfiguriert oder die Verbindung neu angelegt, kann der Index abweichen. Bei falschem Index kommt eine leere oder fehlerhafte Antwort zurück.
data nicht als gültiges JSON aufgebaut: Tippe den JSON-String nie von Hand zusammen. Sobald Anführungszeichen, Backslashes oder Umlaute im Wert stehen, brichst du das JSON. Baue immer ein Objekt und nutze JsonConvert.SerializeObject, das escaped korrekt.
Tippfehler im Request-Namen: requestType muss exakt dem obs-websocket-Request-Namen entsprechen, inklusive Groß- und Kleinschreibung. SetInputSettings funktioniert, setinputsettings oder SetInputSetting nicht. OBS antwortet dann mit einem Fehlerstatus statt mit Daten.
obs-websocket nicht verbunden: Ist OBS gar nicht verbunden, gibt ObsSendRaw nichts Brauchbares zurück. Prüfe die Antwort mit string.IsNullOrEmpty und logge eine Warnung, statt blind JObject.Parse auf einen leeren String zu werfen. Die Verbindung selbst richtest du im OBS-Setup ein.
Falsche Feldnamen im data-Objekt: obs-websocket erwartet exakt benannte Felder wie inputName oder sceneName. Schreibst du sourceName statt inputName, ignoriert OBS das Feld oder meldet einen Fehler. Die korrekten Feldnamen stehen pro Request in der Protokoll-Referenz.