SRT-Routen

Verwenden Sie SRT-Routen, um einen SRT- oder UDP-Eingang ohne zusätzlichen Transcoding-Workflow an ein SRT-Ziel weiterzuleiten.

FunktionSRT-Medien an ein Ziel routen

Geeignet, wennSRT oder UDP soll ohne Transcodierung an ein SRT-Ziel weitergeleitet werden.

Anderes Modul verwenden, wennVerwenden Sie Restreams für Transcodierung, Overlays oder Protokollwechsel und SRT-Server für verwalteten Ingest und Failover.

1SRT-Eingang auswählen2Ziel festlegen3Route starten

POST /api/srt-routes/create

Endpunkte filtern8 Endpunkte

Voraussetzungen

Alle Methoden erfordern einen gültigen x-access-token. Reservieren Sie alle lokalen Listen-Ports und bestätigen Sie, dass URL-Ziele erreichbar sind. Konfigurieren Sie SRT-Modus, Latenz, Passphrase und Stream-Identität konsistent an beiden Enden.

Funktionen

create und update konfigurieren die Eingabe-, Ausgabe- und SRT-Transporteinstellungen.
getAll, getCount und getById inspizieren Routen.
start und stop steuern den Transportweg.
remove löscht eine Route.

Beispiel-Workflow

Wählen Sie eine Eingabe: lokaler SRT-Listener, SRT-URL oder unterstützte UDP-Quelle.
Wählen Sie eine Ausgabe aus: lokaler SRT-Listener oder SRT-Ziel-URL.
Erstellen Sie die Route mit den erforderlichen Transporteinstellungen.
Starten Sie die Route und prüfen Sie Quelle und Ziel unabhängig voneinander.
Verwenden Sie die Routenausgabe als stabilen Eingang für ein anderes Modul bei Bedarf.

Typische Anwendungsfälle

Leiten Sie einen Contribution-Stream vom Veranstaltungsort an eine regionale Produktionsinstanz weiter.
Überbrückung einer UDP-Quelle in einen SRT-Lieferpfad ohne Transcodierung.
Stellen Sie einen Contribution-Feed über eine stabile SRT-Übergabe für nachgelagerte Aufzeichnung oder Verteilung bereit.

Einschränkungen und Fehlerbehebung

Eine Route repariert keine nicht verfügbare Quelle oder ein nicht verfügbares Ziel. Listen-Ports müssen frei sein, URLs müssen erreichbar sein und SRT-Parameter müssen kompatibel sein. Verwenden Sie stattdessen Restreams, wenn der Workflow Transcodierung, Overlays, Medienmodifikation oder breitere Ausgabeoptionen benötigt.

Nächste Schritte

Verbinden Sie die Route mit dem vorgesehenen Restream, der Aufzeichnung oder einem anderen unterstützten Verbraucher und testen Sie den gesamten Pfad.

REST-Lösungsrezept

SRT ohne Transcoding routen oder replizieren

Erstellen Sie eine persistente Transportroute von SRT oder UDP zu einem SRT-Ziel, starten und prüfen Sie die gespeicherte Route.

Route erstellenWählen Sie geprüfte Quellen- und SRT-Ziel-Presets.POST /api/srt-routes/create
Routing startenStarten Sie nach Bestätigung der Erreichbarkeit.POST /api/srt-routes/start
Route prüfenLesen Sie Quelle, Ziel und aktiven Status.POST /api/srt-routes/getById

Nutzen Sie SRT-Routen für reine Transportübergaben. Verwenden Sie Restreams für Protokollwechsel, Transcoding, Skalierung, Audioänderungen oder Overlays.

POST

/api/srt-routes/create

API-Token erforderlich

Erstellen Sie eine SRT-Route mit Name, Quelle, Ziel und anfänglichem Aktivstatus. Senden Sie das API-Token im x-access-token-Header.

Die Antwort enthält die erstellte Route und success: true. Die Arrays input und output sind unmittelbar nach der Erstellung leer; rufen Sie getById auf, wenn Sie die erweiterten verknüpften Objekte benötigen.

Typische Anwendungsfälle

Schalten Sie eine stabile SRT-Übergabe vor Restream-Jobs, deren Ziele sich zwischen Veranstaltungen ändern.
Stellen Sie geplanten Aufzeichnungsjobs eine gleichbleibende Routenausgabe bereit, statt jeden Job direkt an die ursprüngliche Contribution-Quelle zu binden.
Erstellen Sie die Route bei Bedarf aus vMix und verwenden Sie danach start und stop für die normale Bedienung.

Anfragebeispiele

Wählen Sie die Voreinstellung, die mit Quelle und Ziel übereinstimmt, und fügen Sie dann nur die für diesen Pfad erforderlichen Transporteinstellungen hinzu.

SRT-Listener-Port

Die Route hört auf einem lokalen SRT-Port und übernimmt die Übergabe des eingehenden Contribution-Streams.

SRT-Listener-Port zu SRT-Listener-Port

Ziel-Voreinstellung: SRT listen port. Die Route stellt einen lokalen SRT-Listener-Port für nachgelagerte Empfänger bereit, die später eine Verbindung herstellen.

SRT-Listener-Port zu SRT-Listener-Port

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT-Listener-Port zur SRT-Ausgabe-URL

Ziel-Voreinstellung: SRT Output URL. Die Route wird sofort zu einer nachgelagerten SRT-Ziel-URL weitergeleitet.

SRT-Listener-Port zur SRT-Ausgabe-URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT-Listener-Port zur UDP-Ausgabe-URL

Ziel-Voreinstellung: UDP Output URL. Die Route wird an eine nachgelagerte UDP-Ziel-URL weitergeleitet, wenn der nächste Hop UDP erwartet.

SRT-Listener-Port zur UDP-Ausgabe-URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT listen port to UDP Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_LISTEN",
    "input_stream_listen_port": {
      "port": 2035,
      "transport": "udp"
    },
    "input_settings": {
      "host": "0.0.0.0",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_UDP_URL",
    "output_stream_url": "udp://destination.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT-Stream-URL

Die Route wird von einer vorgelagerten SRT-URL abgerufen, anstatt auf einen lokalen Listener-Port zu warten.

SRT-Stream-URL zu SRT-Listener-Port

Ziel-Voreinstellung: SRT listen port. Die Route stellt einen lokalen SRT-Listener-Port für nachgelagerte Empfänger bereit, die später eine Verbindung herstellen.

SRT-Stream-URL zu SRT-Listener-Port

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT-Stream-URL zu SRT-Ausgabe-URL

Ziel-Voreinstellung: SRT Output URL. Die Route wird sofort zu einer nachgelagerten SRT-Ziel-URL weitergeleitet.

SRT-Stream-URL zu SRT-Ausgabe-URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

SRT-Stream-URL zu UDP-Ausgabe-URL

Ziel-Voreinstellung: UDP Output URL. Die Route wird an eine nachgelagerte UDP-Ziel-URL weitergeleitet, wenn der nächste Hop UDP erwartet.

SRT-Stream-URL zu UDP-Ausgabe-URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from SRT Stream URL to UDP Output URL",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_UDP_URL",
    "output_stream_url": "udp://destination.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

UDP-Stream-URL

Die Route liest von einer UDP-Quellen-URL, wenn der SRT-Upstream bereits als UDP-Quelle vorliegt.

UDP-Stream-URL zum SRT-Listener-Port

Ziel-Voreinstellung: SRT listen port. Die Route stellt einen lokalen SRT-Listener-Port für nachgelagerte Empfänger bereit, die später eine Verbindung herstellen.

UDP-Stream-URL zum SRT-Listener-Port

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from UDP Stream URL to SRT listen port",
  "input": {
    "input_type": "INPUT_TYPE_UDP_URL",
    "input_stream_url": "udp://upstream.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_LISTEN",
    "output_stream_listen_port": {
      "port": 3035,
      "transport": "udp"
    },
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

UDP-Stream-URL zu SRT-Ausgabe-URL

Ziel-Voreinstellung: SRT Output URL. Die Route wird sofort zu einer nachgelagerten SRT-Ziel-URL weitergeleitet.

UDP-Stream-URL zu SRT-Ausgabe-URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from UDP Stream URL to SRT Output URL",
  "input": {
    "input_type": "INPUT_TYPE_UDP_URL",
    "input_stream_url": "udp://upstream.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

UDP-Stream-URL zu UDP-Ausgabe-URL

Ziel-Voreinstellung: UDP Output URL. Die Route wird an eine nachgelagerte UDP-Ziel-URL weitergeleitet, wenn der nächste Hop UDP erwartet.

UDP-Stream-URL zu UDP-Ausgabe-URL

curl --request POST \
  --url http://localhost/api/srt-routes/create \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "router_name": "Route from UDP Stream URL to UDP Output URL",
  "input": {
    "input_type": "INPUT_TYPE_UDP_URL",
    "input_stream_url": "udp://upstream.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_UDP_URL",
    "output_stream_url": "udp://destination.example.com:5000",
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

Parameter im Request-Body

Grundeinstellungen

router_name

string

Dashboard-Bezeichnung: Routenname.

Zulässige Zeichen: A-Z, a-z, 0-9 und -.

Quelle

input.input_type

string

Dashboard-Bereich: SRT-/UDP-Routenquelle.

Quelltyp der Route. Im Dashboard wird die Option SRT als SRT Stream URL (srt://) angezeigt. Im aktuellen Beispiel wird INPUT_TYPE_SRT_URL verwendet.

input.input_stream_url

string

Dashboard-Bezeichnung: SRT-Stream-URL (srt://).

Verbinden Sie sich mit der angegebenen URL-Adresse und versuchen Sie, den Stream abzurufen. Im aktuellen Beispiel wird eine Listener-URL verwendet: srt://0.0.0.0:2034?mode=listener.

Erweiterte Quelleinstellungen

input.input_settings.rcvbuf

integer

Dashboard-Bezeichnung: Empfangspuffergröße.

Dies ist eine optionale erweiterte SRT-Eingabeeinstellung. Der Dashboard-Tooltip besagt, dass die Standard-Empfangspuffergröße 12058624 Byte ist und der empfohlene Wert 48234496 Byte ist. Live-Route-Tests bestätigen, dass die API dieses Feld akzeptiert und es von getById zurückgibt, wenn es eingestellt ist.

Quelle

input.module_name

string

Name des Eingabemoduls: Verwenden Sie MODULE_SRT_ROUTERS für eine SRT-Route.

Ziel

output.output_type

string

Dashboard-Bereich: SRT-Routenziel.

Dashboard-Bezeichnung: Stream-Ziel.

Im Dashboard wird die Option SRT-Ziel als SRT Output URL (srt://) angezeigt. Im aktuellen Beispiel wird OUTPUT_TYPE_SRT_URL verwendet.

output.output_stream_url

string

Dashboard-Bezeichnung: Ausgabe-Stream-URL.

Spezifizieren Sie die Adresse der Streaming-Plattform oder des Stream-Ziels. Im aktuellen Beispiel wird srt://0.0.0.0:2035 verwendet.

output.module_name

string

Ausgabemodulname: Verwenden Sie MODULE_SRT_ROUTERS für eine SRT-Route.

Quelle

input.input_stream_listen_port.port

integer

Quell-Voreinstellung: SRT-Port.

Wenn die Routenquelle aus der Listener-Port-Voreinstellung des Dashboards aufgebaut ist, ist der Standardport 2035. Dies ist die praktische Alternative zu input.input_stream_url.

Erweiterte Quelleinstellungen

input.input_settings.host

string

Dashboard-Bezeichnung: SRT-Listener-Host.

Lokale IP-Adresse, an die der Listener gebunden wird. Der Dashboard-Tooltip nennt ausdrücklich 0.0.0.0 für alle Schnittstellen und 127.0.0.1 für die ausschließliche Bindung an localhost. Der Standard ist 0.0.0.0.

input.input_settings.latency

integer

Dashboard-Bezeichnung: Latenz.

Definiert die maximal akzeptierte Übertragungslatenz. Der aktuelle Dashboard-Standard für SRT-Routeneinstellungen ist 500 ms.

input.input_settings.rcvlatency

integer

Dashboard-Bezeichnung: Empfangslatenz.

Mindestverzögerung der Empfangspufferung, bevor die Anwendung das Paket erhält. Der aktuelle Dashboard-Standard ist 200 ms.

input.input_settings.fc

integer

Dashboard-Bezeichnung: Größe des Flusskontrollfensters.

Begrenzt die maximale Anzahl von Paketen im Flug. Der aktuelle Dashboard-Standard ist 25600 Pakete.

input.input_settings.inputbw

integer

Dashboard-Bezeichnung: Eingangsbandbreite.

Setzen Sie diese auf die erwartete Bitrate des Live-Streams. Der aktuelle Dashboard-Standard ist 750000 Byte/s.

input.input_settings.oheadbw

integer

Dashboard-Bezeichnung: Bandbreitenreserve.

Bandbreitenreserve in Prozent der Eingangsbandbreite. Der aktuelle Dashboard-Standard ist 25%.

input.input_settings.maxbw

integer

Dashboard-Bezeichnung: Bandbreitenlimit.

Verwenden Sie 0 für das standardmäßige Bandbreitenlimit.

input.input_settings.streamid

string

Dashboard-Bezeichnung: Stream-ID (optional).

Verfügbar im Konfigurationsbereich für SRT-Listener und -Quelle.

input.input_settings.passphrase

string

Dashboard-Bezeichnung: Passphrase (optional).

Passphrase für die verschlüsselte Übertragung. Der Dashboard-Tooltip gibt an, dass sie zwischen 10 und 79 Zeichen liegen muss.

Ziel

output.output_stream_listen_port.port

integer

Listener-Ziel: SRT-Port.

Wenn das Routenziel aus der Listener-Port-Voreinstellung des Dashboards erstellt wird, ist der Standardport 3035. Dies ist die praktische Alternative zu output.output_stream_url.

Erweiterte Zieleinstellungen

output.output_settings.host

string

Dashboard-Bezeichnung: SRT-Host.

Im Listener-Modus ist dies die zu bindende lokale IP-Adresse; im Caller- oder Rendezvous-Modus ist es die Remote-IP-Adresse des Verbindungsziels. Der aktuelle Dashboard-Standard ist 0.0.0.0.

output.output_settings.mode

string

Dashboard-Bezeichnung: Modus.

Mögliche Werte sind Caller, Listener und Rendezvous. Der aktuelle Dashboard-Standard ist die zweite SRT-Modusoption und entspricht dem in der Oberfläche angezeigten Routenformular.

output.output_settings.latency

integer

Dashboard-Bezeichnung: Latenz.

Definiert die maximal akzeptierte Übertragungslatenz. Der aktuelle Dashboard-Standard ist 500 ms.

output.output_settings.rcvlatency

integer

Dashboard-Bezeichnung: Empfangslatenz.

Mindestverzögerung der Empfangspufferung, bevor Daten an die empfangende Anwendung geliefert werden. Der aktuelle Dashboard-Standard ist 200 ms.

output.output_settings.fc

integer

Dashboard-Bezeichnung: Größe des Flusskontrollfensters.

Der aktuelle Dashboard-Standard ist 25600 Pakete.

output.output_settings.sndbuf

integer

Dashboard-Bezeichnung: Sendepuffergröße.

Der aktuelle Dashboard-Standard ist 12288000 Bytes.

output.output_settings.rcvbuf

integer

Dashboard-Bezeichnung: Empfangspuffergröße.

Der aktuelle Dashboard-Standard ist 12288000 Bytes.

output.output_settings.inputbw

integer

Dashboard-Bezeichnung: Eingangsbandbreite.

Der aktuelle Dashboard-Standard ist 750000 Byte/s.

output.output_settings.oheadbw

integer

Dashboard-Bezeichnung: Bandbreitenreserve.

Der aktuelle Dashboard-Standard ist 25%.

output.output_settings.streamid

string

Dashboard-Bezeichnung: Stream-ID (optional).

Der Dashboard-Tooltip weist darauf hin, dass sie nur im Caller-Modus einstellbar ist.

output.output_settings.passphrase

string

Dashboard-Bezeichnung: Passphrase (optional).

Passwort für verschlüsselte Übertragung. Der Dashboard-Tooltip besagt, dass es zwischen 10 und 79 Zeichen liegen muss.

output.output_settings.enforcedencryption

string

Dashboard-Bezeichnung: Erzwungene Verschlüsselung.

Erfordert, dass beide Verbindungspartner entweder die gleiche Passphrase verwenden oder beide die Passphrase weglassen.

output.output_settings.groupconnect

string

Dashboard-Bezeichnung: Gruppenverbindungen akzeptieren.

Ist die Option auf einem Listener-Socket aktiv, kann dieser Gruppenverbindungen annehmen.

output.output_settings.groupminstabletimeo

integer

Dashboard-Bezeichnung: Timeout für Gruppenstabilität.

Der aktuelle Dashboard-Standard ist 60 ms.

output.output_settings.conntimeo

integer

Dashboard-Bezeichnung: Verbindungs-Timeout.

Gilt für Caller- und Rendezvous-Verbindungsmodi. Der aktuelle Dashboard-Standard ist 3000 ms.

Routenzustand

active

boolean

Dashboard-Bezeichnung: Einmal erstellt aktivieren.

Steuert, ob die Route unmittelbar nach der Erstellung aktiviert werden soll.

Antwort

_id

string

Kennung der neu erstellten SRT-Route.

string

Kurzform der erstellten Routenkennung: In API-Antworten stimmt id mit _id überein.

router_name

string

Gespeicherter Name der erstellten Route.

input

array

Unmittelbar nach der Erstellung gibt die API ein leeres input-Array auf der obersten Ebene. Rufen Sie mit getById die aufgelösten Eingabeobjekte ab.

output

array

Unmittelbar nach der Erstellung gibt die API ein leeres output-Array auf der obersten Ebene. Rufen Sie mit getById die aufgelösten Ausgabeobjekte ab.

active

boolean

Ob die Route nach der Erstellung aktiviert ist.

created

string

Erstellungszeitstempel, der von der API zurückgegeben wird.

success

boolean

Die API gibt zusammen mit dem erstellten Routenobjekt ein boolesches Erfolgsflag zurück. Bei Erfolg ist es true.

Antwort: SRT-Route erstellen

JSON

POST

/api/srt-routes/getAll

API-Token erforderlich

Gibt eine Liste von SRT-Routen zurück, die für den authentifizierten Benutzer sichtbar sind.

Senden Sie optionale Paginierungs- und Sortierfelder im Request-Body. Die Antwort ist ein einfaches Array von Routenobjekten ohne zusätzlichen Wrapper.

Jedes Element enthält Routenname, Aktivstatus und die aufgelösten Objekte input und output. Die Methode eignet sich damit für Dashboards, Listen und Statusansichten.

Parameter im Request-Body

Paginierung

limit

integer

Maximale Anzahl von Routen pro Antwortseite.

skip

integer

Offset für die Paginierung. Verwenden Sie 0 für die erste Seite.

sort.created

integer

Sortierrichtung für den Erstellungszeitstempel der Route. Verwenden Sie 1 für aufsteigende Reihenfolge.

Alle SRT-Routen abrufen

Antwort

Antwortliste

[]

array

Die API gibt ein einfaches Array von SRT-Route-Objekten anstelle eines zusätzlichen Wrappers zurück.

router_name

string

Name jeder SRT-Route im zurückgegebenen Array.

Quelle

input[]

array

Erweiterte Eingabeobjekte, die der Route zugeordnet sind, einschließlich des Eingabetyps, der Eingabe-Stream-URL und optionaler input_settings wie rcvbuf, wenn konfiguriert.

Ziel

output[]

array

Erweiterte Ausgabeobjekte, die der Route zugeordnet sind, einschließlich Ausgabetyp und Ausgabe-Stream-URL.

active

boolean

Ob die Route derzeit aktiv ist.

success

boolean

Jeder zurückgegebene Eintrag enthält derzeit success: true in der API-Antwort.

Antwort: Alle SRT-Routen abrufen

JSON

[
  {
    "_id": "69c1de8e28c95839e0dffb74",
    "router_name": "Awesome SRT route updated",
    "input": [
      {
        "_id": "69c1de8e28c95839e0dffb91",
        "input_type": "INPUT_TYPE_SRT_URL",
        "input_stream_url": "srt://0.0.0.0:2034?mode=listener",
        "module_name": "MODULE_SRT_ROUTERS",
        "__v": 0
      }
    ],
    "output": [
      {
        "_id": "69c1de8e28c95839e0dffb94",
        "output_type": "OUTPUT_TYPE_SRT_URL",
        "output_stream_url": "srt://0.0.0.0:2035",
        "module_name": "MODULE_SRT_ROUTERS",
        "__v": 0
      }
    ],
    "active": false,
    "user_id": "69360341db559495f643de6a",
    "created": "2026-03-24T00:45:02.729Z",
    "__v": 0,
    "modified": "2026-03-24T00:45:02.886Z",
    "id": "69c1de8e28c95839e0dffb74",
    "success": true
  }
]

POST

/api/srt-routes/getById

API-Token erforderlich

Lädt eine SRT-Route per ID.

Senden Sie die id der Route im Request-Body. Die Antwort enthält die vollständige Route mit den aufgelösten Arrays input und output.

Verwenden Sie die Methode vor einer Aktualisierung oder wenn eine Detailansicht die vollständige Quell- und Zielkonfiguration benötigt.

Parameter im Request-Body

string

Kennung der SRT-Route, die Sie laden möchten.

SRT-Route nach ID abrufen

Antwort

_id

string

Kennung der gewünschten Route.

router_name

string

Name der angeforderten Route.

input[]

array

Erweiterte Eingabeobjekte für die Routenquelle. Wenn erweiterte SRT-Einstellungen verwendet werden, gibt die API sie auch unter input_settings zurück.

output[]

array

Erweiterte Ausgabeobjekte für das Routenziel.

active

boolean

Ob die Route derzeit aktiviert ist.

success

boolean

Die API gibt das angeforderte Routenobjekt zusammen mit success: true zurück.

Antwort: SRT-Route nach ID abrufen

JSON

{
  "_id": "69c1de8e28c95839e0dffb74",
  "router_name": "Awesome SRT route updated",
  "input": [
    {
      "_id": "69c1de8e28c95839e0dffb91",
      "input_type": "INPUT_TYPE_SRT_URL",
      "input_stream_url": "srt://0.0.0.0:2034?mode=listener",
      "module_name": "MODULE_SRT_ROUTERS",
      "__v": 0
    }
  ],
  "output": [
    {
      "_id": "69c1de8e28c95839e0dffb94",
      "output_type": "OUTPUT_TYPE_SRT_URL",
      "output_stream_url": "srt://0.0.0.0:2035",
      "module_name": "MODULE_SRT_ROUTERS",
      "__v": 0
    }
  ],
  "active": false,
  "user_id": "69360341db559495f643de6a",
  "created": "2026-03-24T00:45:02.729Z",
  "__v": 0,
  "modified": "2026-03-24T00:45:02.886Z",
  "id": "69c1de8e28c95839e0dffb74",
  "success": true
}

POST

/api/srt-routes/update

API-Token erforderlich

Aktualisiert eine bestehende SRT-Route nach ID.

Senden Sie die id der Route zusammen mit den vollständig aktualisierten Feldern für Quelle, Ziel und Aktivstatus.

Die Antwort enthält die aktualisierte Route und success: true. Die Arrays input und output sind unmittelbar nach der Aktualisierung leer; rufen Sie getById für erweiterte verknüpfte Objekte auf.

Parameter im Request-Body

string

Kennung der Route, die Sie aktualisieren möchten.

router_name

string

Aktualisierter Routenname.

input

object

Aktualisiertes Quellkonfigurationsobjekt für die Route.

output

object

Aktualisiertes Zielkonfigurationsobjekt für die Route.

active

boolean

Aktualisierter Aktivstatus für die Route.

SRT-Route aktualisieren

curl --request POST \
  --url http://localhost/api/srt-routes/update \
  --header 'x-access-token: <your_api_token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "id": "SRT_ROUTE_ID",
  "router_name": "Awesome SRT route updated",
  "input": {
    "input_type": "INPUT_TYPE_SRT_URL",
    "input_stream_url": "srt://upstream.example.com:2034?mode=caller",
    "input_settings": {
      "rcvbuf": 48234496
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "output": {
    "output_type": "OUTPUT_TYPE_SRT_URL",
    "output_stream_url": "srt://destination.example.com:1935",
    "output_settings": {
      "host": "0.0.0.0",
      "mode": "listener",
      "latency": 500,
      "rcvlatency": 200,
      "fc": 25600,
      "sndbuf": 12288000,
      "rcvbuf": 12288000,
      "inputbw": 750000,
      "oheadbw": 25,
      "groupconnect": "yes",
      "groupminstabletimeo": 60,
      "conntimeo": 3000
    },
    "module_name": "MODULE_SRT_ROUTERS"
  },
  "active": true
}'

Antwort

router_name

string

Aktualisierter Routenname, der von der API zurückgegeben wird.

modified

string

Änderungszeitstempel, den die API setzt.

input

array

Unmittelbar nach der Aktualisierung gibt die API derzeit leere Arrays der obersten Ebene input und output zurück.

success

boolean

Die API gibt das aktualisierte Routenobjekt zusammen mit success: true zurück.

Antwort: SRT-Route aktualisieren

JSON

POST

/api/srt-routes/start

API-Token erforderlich

Startet eine SRT-Route per ID.

Senden Sie die id der Route. Die Antwort enthält die aktualisierte Route und success: true. Nach einem erfolgreichen Start gilt active: true; input und output enthalten verknüpfte Objekt-IDs statt aufgelöster Objekte.

Hinweis zu vMix: Die Methode eignet sich für Schaltflächen, Shortcuts oder Trigger, wenn die Route bereits existiert und Operatoren sie nur zum richtigen Zeitpunkt online bringen müssen.

Parameter im Request-Body

string

Kennung der Route, die Sie starten möchten.

SRT-Route starten

Antwort

input

array

Nach dem Start gibt die API input als ein Array von verknüpften Eingabeobjekt-IDs zurück.

output

array

Nach dem Start gibt die API output als ein Array von verknüpften IDs der Ausgabeobjekte zurück.

active

boolean

Wird true, wenn die Route erfolgreich gestartet wird.

success

boolean

Die API gibt das aktualisierte Routenobjekt zusammen mit success: true zurück.

Antwort: SRT-Route starten

JSON

POST

/api/srt-routes/stop

API-Token erforderlich

Stoppt eine SRT-Route per ID.

Senden Sie die id der Route. Die Antwort enthält die aktualisierte Route und success: true. Nach einem erfolgreichen Stopp gilt active: false; input und output bleiben verknüpfte Objekt-IDs.

Hinweis zu vMix: Kombinieren Sie diese Methode in Bedienelementen mit Start SRT route, um die Route offline zu nehmen, ohne sie zu löschen.

Parameter im Request-Body

string

Kennung der Route, die Sie stoppen möchten.

SRT-Route stoppen

Antwort

input

array

Nach dem Stopp gibt die API weiterhin verknüpfte Eingabeobjekt-IDs anstelle von erweiterten Objekten zurück.

output

array

Nach dem Stopp gibt die API weiterhin verknüpfte Ausgabeobjekt-IDs anstelle von erweiterten Objekten zurück.

active

boolean

Wird false, wenn die Route erfolgreich gestoppt wird.

success

boolean

Die API gibt das aktualisierte Routenobjekt zusammen mit success: true zurück.

Antwort: SRT-Route stoppen

JSON

POST

/api/srt-routes/getCount

API-Token erforderlich

DELETE

/api/srt-routes/remove

API-Token erforderlich

Zurück zuRTMP-Server Weiter zuErkannte NDI-Geräte