go2rtc Documentation

[!WARNING]
This source is under development and does not always work well.

Advanced Linux Sound Architecture - a framework for receiving audio from devices on Linux OS.

Easy to add via WebUI > add > ALSA.

Alternatively, you can use FFmpeg source.

Overview (`internal/api/README.md`)

HTTP API

The HTTP API is the main part for interacting with the application. Default address: http://localhost:1984/.

The HTTP API is described in OpenAPI format. It can be explored in interactive viewer. WebSocket API described here.

The project's static HTML and JS files are located in the www folder. An external developer can use them as a basis for integrating go2rtc into their project or for developing a custom web interface for go2rtc.

The contents of www folder are built into go2rtc when building, but you can use configuration to specify an external folder as the source of static files.

Configuration

Important! go2rtc passes requests from localhost and Unix sockets without HTTP authorization, even if you have it configured. It is your responsibility to set up secure external access to the API. If not properly configured, an attacker can gain access to your cameras and even your server.

you can disable HTTP API with listen: "" and use, for example, only RTSP client/server protocol
you can enable HTTP API only on localhost with listen: "127.0.0.1:1984" setting
you can change the API base_path and host go2rtc on your main app webserver suburl
all files from static_dir hosted on root path: /
you can use raw TLS cert/key content or path to files

yaml

api:
  listen: ":1984"    # default ":1984", HTTP API port ("" - disabled)
  username: "admin"  # default "", Basic auth for WebUI
  password: "pass"   # default "", Basic auth for WebUI
  local_auth: true   # default false, Enable auth check for localhost requests
  base_path: "/rtc"  # default "", API prefix for serving on suburl (/api => /rtc/api)
  static_dir: "www"  # default "", folder for static files (custom web interface)
  origin: "*"        # default "", allow CORS requests (only * supported)
  tls_listen: ":443" # default "", enable HTTPS server
  tls_cert: |        # default "", PEM-encoded fullchain certificate for HTTPS
    -----BEGIN CERTIFICATE-----
    ...
    -----END CERTIFICATE-----
  tls_key: |         # default "", PEM-encoded private key for HTTPS
    -----BEGIN PRIVATE KEY-----
    ...
    -----END PRIVATE KEY-----
  unix_listen: "/tmp/go2rtc.sock"  # default "", unix socket listener for API

PS:

MJPEG over WebSocket plays better than native MJPEG because Chrome bug
MP4 over WebSocket was created only for Apple iOS because it doesn't support file streaming

Overview (`internal/app/README.md`)

App

The application module is responsible for reading configuration files, running other modules and setting up logs.

The configuration can be edited through the application's WebUI with code highlighting, syntax and specification checking.

By default, go2rtc will search for the go2rtc.yaml config file in the current working directory
go2rtc supports multiple config files:
- go2rtc -c config1.yaml -c config2.yaml -c config3.yaml
go2rtc supports inline config in multiple formats from the command line:
- YAML: go2rtc -c '{log: {format: text}}'
- JSON: go2rtc -c '{"log":{"format":"text"}}'
- key=value: go2rtc -c log.format=text
Each subsequent config will overwrite the previous one (but only for defined params)

text

go2rtc -config "{log: {format: text}}" -config /config/go2rtc.yaml -config "{rtsp: {listen: ''}}" -config /usr/local/go2rtc/go2rtc.yaml

or a simpler version

text

go2rtc -c log.format=text -c /config/go2rtc.yaml -c rtsp.listen='' -c /usr/local/go2rtc/go2rtc.yaml

Environment variables

There is support for loading external variables into the config. First, they will be loaded from credential files. If CREDENTIALS_DIRECTORY is not set, then the key will be loaded from an environment variable. If no environment variable is set, then the string will be left as-is.

yaml

streams:
  camera1: rtsp://rtsp:${CAMERA_PASSWORD}@192.168.1.123/av_stream/ch0

rtsp:
  username: ${RTSP_USER:admin}   # "admin" if "RTSP_USER" not set
  password: ${RTSP_PASS:secret}  # "secret" if "RTSP_PASS" not set

JSON Schema

Editors like GoLand and VS Code support autocomplete and syntax validation.

yaml

# yaml-language-server: $schema=https://raw.githubusercontent.com/AlexxIT/go2rtc/master/www/schema.json

or from a running go2rtc:

yaml

# yaml-language-server: $schema=http://localhost:1984/schema.json

Defaults

Default values may change in updates
FFmpeg module has many presets, they are not listed here because they may also change in updates

yaml

api:
  listen: ":1984"  # default public port for WebUI and HTTP API

ffmpeg:
  bin: "ffmpeg"    # default binary path for FFmpeg

log:
  level: "info"    # default log level
  output: "stdout"
  time: "UNIXMS"

rtsp:
  listen: ":8554"  # default public port for RTSP server
  default_query: "video&audio"

srtp:
  listen: ":8443"  # default public port for SRTP server (used for HomeKit)

webrtc:
  listen: ":8555"  # default public port for WebRTC server (TCP and UDP)
  ice_servers:
    - urls: [ "stun:stun.cloudflare.com:3478", "stun:stun.l.google.com:19302" ]

Log

You can set different log levels for different modules.

yaml

log:
  format: ""        # empty (default, autodetect color support), color, json, text 
  level: "info"     # disabled, trace, debug, info (default), warn, error
  output: "stdout"  # empty (only to memory), stderr, stdout (default)
  time: "UNIXMS"    # empty (disable timestamp), UNIXMS (default), UNIXMICRO, UNIXNANO
  
  api: trace   # module name: log level

Modules: api, streams, rtsp, webrtc, mp4, hls, mjpeg, hass, homekit, onvif, rtmp, webtorrent, wyoming, echo, exec, expr, ffmpeg, wyze, xiaomi.

Overview (`internal/bubble/README.md`)

Bubble

new in v1.6.1

Private format in some cameras from dvr163.com and eseecloud.com.

Configuration

you can skip username, password, port, ch and stream if they are default
set up separate streams for different channels and streams

yaml

streams:
  camera1: bubble://username:[email protected]:34567/bubble/live?ch=0&stream=0

Overview (`internal/debug/README.md`)

Debug

This module provides GET /api/stack, with which you can find hanging goroutines

Overview (`internal/doorbird/README.md`)

Doorbird

new in v1.9.8

This source type supports Doorbird devices including MJPEG stream, audio stream as well as two-way audio.

It is recommended to create a separate user within your doorbird setup for go2rtc. Minimum permissions for the user are:

Watch always
API operator

Configuration

yaml

streams:
  doorbird1:
    - rtsp://admin:[email protected]:8557/mpeg/720p/media.amp  # RTSP stream
    - doorbird://admin:[email protected]?media=video           # MJPEG stream
    - doorbird://admin:[email protected]?media=audio           # audio stream
    - doorbird://admin:[email protected]                       # two-way audio

Overview (`internal/dvrip/README.md`)

DVR-IP

new in v1.2.0

Private format from DVR-IP NVR, NetSurveillance, Sofia protocol (NETsurveillance ActiveX plugin XMeye SDK).

Configuration

you can skip username, password, port, channel and subtype if they are default
set up separate streams for different channels
use subtype=0 for Main stream, and subtype=1 for Extra1 stream
only the TCP protocol is supported

yaml

streams:
  only_stream: dvrip://username:[email protected]:34567?channel=0&subtype=0
  only_tts: dvrip://username:[email protected]:34567?backchannel=1
  two_way_audio:
    - dvrip://username:[email protected]:34567?channel=0&subtype=0
    - dvrip://username:[email protected]:34567?backchannel=1

Overview (`internal/echo/README.md`)

Echo

Some sources may have a dynamic link. And you will need to get it using a Bash or Python script. Your script should echo a link to the source. RTSP, FFmpeg or any of the supported sources.

Docker and Home Assistant add-on users have preinstalled python3, curl, jq.

Configuration

yaml

streams:
  apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html

Install python libraries

Docker and Hass Add-on users have preinstalled python3 without any additional libraries, like requests or others. If you need some additional libraries - you need to install them to folder with your script:

Install SSH & Web Terminal
Goto Add-on Web UI
Install library: pip install requests -t /config/echo
Add your script to /config/echo/myscript.py
Use your script as source echo:python3 /config/echo/myscript.py

Example: Apple HLS

yaml

streams:
  apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html

hls.py

python

import re
import sys
from urllib.parse import urljoin
from urllib.request import urlopen

html = urlopen(sys.argv[1]).read().decode("utf-8")
url = re.search(r"https.+?m3u8", html)[0]

html = urlopen(url).read().decode("utf-8")
m = re.search(r"^[a-z0-1/_]+\.m3u8$", html, flags=re.MULTILINE)
url = urljoin(url, m[0])

# ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear1/prog_index.m3u8#video=copy
print("ffmpeg:" + url + "#video=copy")

Overview (`internal/eseecloud/README.md`)

EseeCloud

This source is for cameras with a link like this http://admin:@192.168.1.123:80/livestream/12. Related issue.

Configuration

yaml

streams:
  camera1: eseecloud://user:[email protected]:80/livestream/12

Overview (`internal/exec/README.md`)

Exec

Exec source can run any external application and expect data from it. Two transports are supported - pipe (new in v1.5.0) and RTSP.

If you want to use RTSP transport, the command must contain the {output} argument in any place. On launch, it will be replaced by the local address of the RTSP server.

pipe reads data from app stdout in different formats: MJPEG, H.264/H.265 bitstream, MPEG-TS. Also pipe can write data to app stdin in two formats: PCMA and PCM/48000.

The source can be used with:

FFmpeg - go2rtc ffmpeg source is just a shortcut to exec source
FFplay - play audio on your server
GStreamer
Raspberry Pi Cameras
any of your own software

Configuration

Pipe commands support parameters (format: exec:{command}#{param1}#{param2}):

killsignal - signal which will be sent to stop the process (numeric form)
killtimeout - time in seconds for forced termination with sigkill
backchannel - enable backchannel for two-way audio
starttimeout - time in seconds for waiting first byte from RTSP

yaml

streams:
  stream: exec:ffmpeg -re -i /media/BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp {output}
  picam_h264: exec:libcamera-vid -t 0 --inline -o -
  picam_mjpeg: exec:libcamera-vid -t 0 --codec mjpeg -o -
  pi5cam_h264: exec:libcamera-vid -t 0 --libav-format h264 -o -
  canon: exec:gphoto2 --capture-movie --stdout#killsignal=2#killtimeout=5
  play_pcma: exec:ffplay -fflags nobuffer -f alaw -ar 8000 -i -#backchannel=1
  play_pcm48k: exec:ffplay -fflags nobuffer -f s16be -ar 48000 -i -#backchannel=1

Backchannel

You can check audio card names in the Go2rtc > WebUI > Add
You can specify multiple backchannel lines with different codecs

yaml

sources:
  two_way_audio_win:
    - exec:ffmpeg -hide_banner -f dshow -i "audio=Microphone (High Definition Audio Device)" -c pcm_s16le -ar 16000 -ac 1 -f wav -
    - exec:ffplay -nodisp -probesize 32 -f s16le -ar 16000 -#backchannel=1#audio=s16le/16000
    - exec:ffplay -nodisp -probesize 32 -f alaw -ar 8000 -#backchannel=1#audio=alaw/8000

Overview (`internal/expr/README.md`)

Expr

new in v1.8.2

Expr - expression language and expression evaluation for Go.

language definition - takes best from JS, Python, Jinja2 syntax
your expression should return a link of any supported source
expression supports multiple operation, but:
- all operations must be separated by a semicolon
- all operations, except the last one, must declare a new variable (let s = "abc";)
- the last operation should return a string
go2rtc supports additional functions:
- fetch - JS-like HTTP requests
- match - JS-like RegExp queries

Fetch examples

Multiple fetch requests are executed within a single session. They share the same cookie.

HTTP GET

var r = fetch('https://example.org/products.json');

HTTP POST JSON

var r = fetch('https://example.org/post', {
    method: 'POST',
    // Content-Type: application/json will be set automatically
    json: {username: 'example'}
});

HTTP POST Form

var r = fetch('https://example.org/post', {
    method: 'POST',
    // Content-Type: application/x-www-form-urlencoded will be set automatically
    data: {username: 'example', password: 'password'}
});

Script examples

Two way audio for Dahua VTO

yaml

streams:
  dahua_vto: |
    expr:
    let host = 'admin:[email protected]';

    var r = fetch('http://' + host + '/cgi-bin/configManager.cgi?action=setConfig&Encode[0].MainFormat[0].Audio.Compression=G.711A&Encode[0].MainFormat[0].Audio.Frequency=8000');

    'rtsp://' + host + '/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif'

dom.ru

You can get credentials from https://github.com/ad/domru

yaml

streams:
  dom_ru: |
    expr:
    let camera   = '***';
    let token    = '***';
    let operator = '***';

    fetch('https://myhome.proptech.ru/rest/v1/forpost/cameras/' + camera + '/video', {
      headers: {
        'Authorization': 'Bearer ' + token,
        'User-Agent': 'Google sdkgphone64x8664 | Android 14 | erth | 8.26.0 (82600010) | 0 | 0 | 0',
        'Operator': operator
      }
    }).json().data.URL

dom.ufanet.ru

yaml

streams:
  ufanet_ru: |
    expr:
    let username = '***';
    let password = '***';
    let cameraid = '***';

    let r1 = fetch('https://ucams.ufanet.ru/api/internal/login/', {
      method: 'POST',
      data: {username: username, password: password}
    });
    let r2 = fetch('https://ucams.ufanet.ru/api/v0/cameras/this/?lang=ru', {
      method: 'POST',
      json: {'fields': ['token_l', 'server'], 'token_l_ttl': 3600, 'numbers': [cameraid]},
    }).json().results[0];

    'rtsp://' + r2.server.domain + '/' + r2.number + '?token=' + r2.token_l

Parse HLS files from Apple

Same example in two languages - python and expr.

yaml

streams:
  example_python: |
    echo:python -c 'from urllib.request import urlopen; import re

    # url1 = "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/bipbop_16x9_variant.m3u8"
    html1 = urlopen("https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html").read().decode("utf-8")
    url1 = re.search(r"https.+?m3u8", html1)[0]

    # url2 = "gear1/prog_index.m3u8"
    html2 = urlopen(url1).read().decode("utf-8")
    url2 = re.search(r"^[a-z0-1/_]+\.m3u8$", html2, flags=re.MULTILINE)[0]

    # url3 = "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear1/prog_index.m3u8"
    url3 = url1[:url1.rindex("/")+1] + url2

    print("ffmpeg:" + url3 + "#video=copy")'

  example_expr: |
    expr:

    let html1 = fetch("https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html").text;
    let url1 = match(html1, "https.+?m3u8")[0];

    let html2 = fetch(url1).text;
    let url2 = match(html2, "^[a-z0-1/_]+\\.m3u8$", "m")[0];

    let url3 = url1[:lastIndexOf(url1, "/")+1] + url2;

    "ffmpeg:" + url3 + "#video=copy"

Comparison

expr	python	js
let x = 1;	x = 1	let x = 1
{a: 1, b: 2}	{"a": 1, "b": 2}	{a: 1, b: 2}
let r = fetch(url, {method})	r = request(method, url)	r = await fetch(url, {method})
r.ok	r.ok	r.ok
r.status	r.status_code	r.status
r.text	r.text	await r.text()
r.json()	r.json()	await r.json()
r.headers	r.headers	r.headers
let m = match(text, "abc")	m = re.search("abc", text)	let m = text.match(/abc/)

Overview (`internal/ffmpeg/README.md`)

FFmpeg

You can get any stream, file or device via FFmpeg and push it to go2rtc. The app will automatically start FFmpeg with the proper arguments when someone starts watching the stream.

FFmpeg preinstalled for Docker and Home Assistant add-on users
Home Assistant add-on users can target files from /media folder

Configuration

Format: ffmpeg:{input}#{param1}#{param2}#{param3}. Examples:

yaml

streams:
  # [FILE] all tracks will be copied without transcoding codecs
  file1: ffmpeg:/media/BigBuckBunny.mp4

  # [FILE] video will be transcoded to H264, audio will be skipped
  file2: ffmpeg:/media/BigBuckBunny.mp4#video=h264

  # [FILE] video will be copied, audio will be transcoded to PCMU
  file3: ffmpeg:/media/BigBuckBunny.mp4#video=copy#audio=pcmu

  # [HLS] video will be copied, audio will be skipped
  hls: ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear5/prog_index.m3u8#video=copy

  # [MJPEG] video will be transcoded to H264
  mjpeg: ffmpeg:http://185.97.122.128/cgi-bin/faststream.jpg#video=h264

  # [RTSP] video with rotation, should be transcoded, so select H264
  rotate: ffmpeg:rtsp://[email protected]/av_stream/ch0#video=h264#rotate=90

All transcoding formats have built-in templates: h264, h265, opus, pcmu, pcmu/16000, pcmu/48000, pcma, pcma/16000, pcma/48000, aac, aac/16000.

But you can override them via YAML config. You can also add your own formats to the config and use them with source params.

yaml

ffmpeg:
  bin: ffmpeg  # path to ffmpeg binary
  global: "-hide_banner"
  timeout: 5  # default timeout in seconds for rtsp inputs
  h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
  mycodec: "-any args that supported by ffmpeg..."
  myinput: "-fflags nobuffer -flags low_delay -timeout {timeout} -i {input}"
  myraw: "-ss 00:00:20"

You can use go2rtc stream name as ffmpeg input (ex. ffmpeg:camera1#video=h264)
You can use video and audio params multiple times (ex. #video=copy#audio=copy#audio=pcmu)
You can use rotate param with 90, 180, 270 or -90 values, important with transcoding (ex. #video=h264#rotate=90)
You can use width and/or height params, important with transcoding (ex. #video=h264#width=1280)
You can use drawtext to add a timestamp (ex. drawtext=x=2:y=2:fontsize=12:fontcolor=white:box=1:boxcolor=black)
- This will greatly increase the CPU of the server, even with hardware acceleration
You can use timeout param to set RTSP input timeout in seconds (ex. #timeout=10)
You can use raw param for any additional FFmpeg arguments (ex. #raw=-vf transpose=1)
You can use input param to override default input template (ex. #input=rtsp/udp will change RTSP transport from TCP to UDP+TCP)
- You can use raw input value (ex. #input=-timeout {timeout} -i {input})
- You can add your own input templates

Overview (`internal/flussonic/README.md`)

Flussonic

Support streams from Flussonic server. Related issue.

Overview (`internal/gopro/README.md`)

GoPro

new in v1.8.3

Support streaming from GoPro cameras, connected via USB or Wi-Fi to Linux, Mac, Windows.

Supported models: HERO9, HERO10, HERO11, HERO12.
Supported OS: Linux, Mac, Windows, HassOS

Other camera models have different APIs. I will try to add them in future versions.

Configuration

USB-connected cameras create a new network interface in the system
Linux users do not need to install anything
Windows users should install the network driver
if the camera is detected but the stream does not start, you need to disable the firewall

Discover camera address: WebUI > Add > GoPro
Add camera to config

yaml

streams:
  hero12: gopro://172.20.100.51

Useful links

https://gopro.github.io/OpenGoPro/

Overview (`internal/hass/README.md`)

Hass

Support import camera links from Home Assistant config files:

Generic Camera, setup via GUI
HomeKit Camera
ONVIF
Roborock vacuums with camera

Configuration

yaml

hass:
  config: "/config"  # skip this setting if you are a Home Assistant add-on user

streams:
  generic_camera: hass:Camera1  # Settings > Integrations > Integration Name
  aqara_g3: hass:Camera-Hub-G3-AB12

WebRTC Cameras

new in v1.6.0

Any cameras in WebRTC format are supported. But at the moment Home Assistant only supports some Nest cameras in this format.

Important. The Nest API only allows you to get a link to a stream for 5 minutes.
Do not use this with Frigate! If the stream expires, Frigate will consume all available RAM on your machine within seconds.
It's recommended to use Nest source - it supports extending the stream.

yaml

streams:
  # link to Home Assistant Supervised
  hass-webrtc1: hass://supervisor?entity_id=camera.nest_doorbell
  # link to external Home Assistant with Long-Lived Access Tokens
  hass-webrtc2: hass://192.168.1.123:8123?entity_id=camera.nest_doorbell&token=eyXYZ...

RTSP Cameras

By default, the Home Assistant API does not allow you to get a dynamic RTSP link to a camera stream. This method can work around it.

Overview (`internal/hls/README.md`)

HLS

new in v1.1.0

HLS is the worst technology for real-time streaming.
It can only be useful on devices that do not support more modern technology, like WebRTC, MP4.

The go2rtc implementation differs from the standards and may not work with all players.

API examples:

HLS/TS stream: http://192.168.1.123:1984/api/stream.m3u8?src=camera1 (H264)
HLS/fMP4 stream: http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4 (H264, H265, AAC)

Useful links

https://walterebert.com/playground/video/hls/

Overview (`internal/homekit/README.md`)

Apple HomeKit

This module supports both client and server for the Apple HomeKit protocol.

HomeKit Client

Important:

You can use HomeKit Cameras without Apple devices (iPhone, iPad, etc.), it's just a yet another protocol
HomeKit device can be paired with only one ecosystem. So, if you have paired it to an iPhone (Apple Home), you can't pair it with Home Assistant or go2rtc. Or if you have paired it to go2rtc, you can't pair it with an iPhone
HomeKit device should be on the same network with working mDNS between the device and go2rtc

go2rtc supports importing paired HomeKit devices from Home Assistant.
So you can use HomeKit camera with Home Assistant and go2rtc simultaneously.
If you are using Home Assistant, I recommend pairing devices with it; it will give you more options.

You can pair device with go2rtc on the HomeKit page. If you can't see your devices, reload the page.
Also, try rebooting your HomeKit device (power off). If you still can't see it, you have a problem with mDNS.

If you see a device but it does not have a pairing button, it is paired to some ecosystem (Apple Home, Home Assistant, HomeBridge, etc.). You need to delete the device from that ecosystem, and it will be available for pairing. If you cannot unpair the device, you will have to reset it.

Important:

HomeKit audio uses very non-standard AAC-ELD codec with very non-standard params and specification violations
Audio can't be played in VLC and probably any other player
Audio should be transcoded for use with MSE, WebRTC, etc.

Client Configuration

Recommended settings for using HomeKit Camera with WebRTC, MSE, MP4, RTSP:

yaml

streams:
  aqara_g3:
    - hass:Camera-Hub-G3-AB12
    - ffmpeg:aqara_g3#audio=aac#audio=opus

RTSP link with "normal" audio for any player: rtsp://192.168.1.123:8554/aqara_g3?video&audio=aac

This source is in active development! Tested only with Aqara Camera Hub G3 (both EU and CN versions).

HomeKit Server

HomeKit module can work in two modes:

export any H264 camera to Apple HomeKit
transparent proxy any Apple HomeKit camera (Aqara, Eve, Eufy, etc.) back to Apple HomeKit, so you will have all camera features in Apple Home and also will have RTSP/WebRTC/MP4/etc. from your HomeKit camera

Important

HomeKit cameras support only H264 video and OPUS audio

Server Configuration

Minimal config

yaml

streams:
  dahua1: rtsp://admin:[email protected]/cam/realmonitor?channel=1&subtype=0
homekit:
  dahua1:  # same stream ID from streams list, default PIN - 19550224

Full config

yaml

streams:
  dahua1:
    - rtsp://admin:[email protected]/cam/realmonitor?channel=1&subtype=0
    - ffmpeg:dahua1#video=h264#hardware  # if your camera doesn't support H264, important for HomeKit
    - ffmpeg:dahua1#audio=opus           # only OPUS audio supported by HomeKit

homekit:
  dahua1:                   # same stream ID from streams list
    pin: 12345678           # custom PIN, default: 19550224
    name: Dahua camera      # custom camera name, default: generated from stream ID
    device_id: dahua1       # custom ID, default: generated from stream ID
    device_private: dahua1  # custom key, default: generated from stream ID

Proxy HomeKit camera

Video stream from HomeKit camera to Apple device (iPhone, Apple TV) will be transmitted directly
Video stream from HomeKit camera to RTSP/WebRTC/MP4/etc. will be transmitted via go2rtc

yaml

streams:
  aqara1:
    - homekit://...
    - ffmpeg:aqara1#audio=aac#audio=opus  # optional audio transcoding

homekit:
  aqara1:  # same stream ID from streams list

Overview (`internal/http/README.md`)

HTTP

This source supports receiving a stream via an HTTP link.

It can determine the source format from theContent-Type HTTP header:

HTTP-JPEG (image/jpeg) - camera snapshot link, can be converted by go2rtc to MJPEG stream
HTTP-MJPEG (multipart/x-mixed-replace) - A continuous sequence of JPEG frames (with HTTP headers).
HLS (application/vnd.apple.mpegurl) - A popular HTTP Live Streaming (HLS) format, which is not designed for real-time media transmission.

[!WARNING]
The HLS format is not designed for real time and is supported quite poorly. It is recommended to use it via ffmpeg source with buffering enabled (disabled by default).

TCP

Source also supports HTTP and TCP streams with autodetection for different formats:

adts - Audio stream in AAC codec with Audio Data Transport Stream (ADTS) headers.
flv - The legacy but still used Flash Video format.
h264 - AVC/H.264 bitstream.
hevc - HEVC/H.265 bitstream.
mjpeg - A continuous sequence of JPEG frames (without HTTP headers).
mpegts - The legacy MPEG transport stream format.
wav - Audio stream in WAV format.
yuv4mpegpipe - Raw YUV frame stream with YUV4MPEG header.

Configuration

yaml

streams:
  # [HTTP-FLV] stream in video/x-flv format
  http_flv: http://192.168.1.123:20880/api/camera/stream/780900131155/657617
  
  # [JPEG] snapshots from Dahua camera, will be converted to MJPEG stream
  dahua_snap: http://admin:[email protected]/cgi-bin/snapshot.cgi?channel=1

  # [MJPEG] stream will be proxied without modification
  http_mjpeg: https://mjpeg.sanford.io/count.mjpeg

  # [MJPEG or H.264/H.265 bitstream or MPEG-TS]
  tcp_magic: tcp://192.168.1.123:12345

  # Add custom header
  custom_header: "https://mjpeg.sanford.io/count.mjpeg#header=Authorization: Bearer XXX"

PS. Dahua camera has a bug: if you select MJPEG codec for RTSP second stream, snapshot won't work.

Overview (`internal/isapi/README.md`)

Hikvision ISAPI

This source type supports only backchannel audio for the Hikvision ISAPI protocol. So it should be used as a second source in addition to the RTSP protocol.

Configuration

yaml

streams:
  hikvision1:
    - rtsp://admin:[email protected]:554/Streaming/Channels/101
    - isapi://admin:[email protected]:80/

Overview (`internal/ivideon/README.md`)

Ivideon

Support public cameras from the service Ivideon.

Configuration

yaml

streams:
  quailcam: ivideon:100-tu5dkUPct39cTp9oNEN2B6/0

Overview (`internal/kasa/README.md`)

TP-Link Kasa

TP-Link Kasa non-standard protocol more info.

username - urlsafe email, [email protected] -> alex%40gmail.com
password - base64password, secret1 -> c2VjcmV0MQ==

yaml

streams:
  kc401: kasa://username:[email protected]:19443/https/stream/mixed

Tested: KD110, KC200, KC401, KC420WS, EC71.

Overview (`internal/mjpeg/README.md`)

Motion JPEG

This module can provide and receive streams in MJPEG format.
This module is also responsible for receiving snapshots in JPEG format.
This module also supports streaming to the server console (terminal) in the animated ASCII art format.

MJPEG Client

Important. For a stream in MJPEG format, your source MUST contain the MJPEG codec. If your stream has the MJPEG codec, you can receive an MJPEG stream or JPEG snapshots via the API.

You can receive an MJPEG stream in several ways:

some cameras support MJPEG codec inside RTSP stream (ex. second stream for Dahua cameras)
some cameras have an HTTP link with MJPEG stream
some cameras have an HTTP link with snapshots - go2rtc can convert them to MJPEG stream
you can convert an H264/H265 stream from your camera via FFmpeg integration

With this example, your stream will have both H264 and MJPEG codecs:

yaml

streams:
  camera1:
    - rtsp://rtsp:[email protected]/av_stream/ch0
    - ffmpeg:camera1#video=mjpeg

MJPEG Server

mpjpeg

Output a stream in MJPEG format. In FFmpeg, this format is called mpjpeg because it contains HTTP headers.

text

ffplay http://192.168.1.123:1984/api/stream.mjpeg?src=camera1

jpeg

Receiving a JPEG snapshot.

text

curl http://192.168.1.123:1984/api/frame.jpeg?src=camera1

You can use width/w and/or height/h parameters.
You can use rotate param with 90, 180, 270 or -90 values.
You can use hardware/hw param read more.
You can use cache param (1m, 10s, etc.) to get a cached snapshot.
- The snapshot is cached only when requested with the cache parameter.
- A cached snapshot will be used if its time is not older than the time specified in the cache parameter.
- The cache parameter does not check the image dimensions from the cache and those specified in the query.

ascii

Stream as ASCII to Terminal. This format is just for fun. You can boast to your friends that you can stream cameras even to the server console without a GUI.

The demo video features a combination of several settings for this format with added audio. Of course, the format doesn't support audio out of the box.

Tips

this feature works only with MJPEG codec (use transcoding)
choose a low frame rate (FPS)
choose the width and height to fit in your terminal
different terminals support different numbers of colors (8, 256, rgb)
URL-encode the text parameter
you can stream any camera or file from disk

go2rtc.yaml - transcoding to MJPEG, terminal size - 210x59 (16/9), fps - 10

yaml

streams:
  gamazda: ffmpeg:gamazda.mp4#video=mjpeg#hardware#width=210#height=59#raw=-r 10

API params

color - foreground color, values: empty, 8, 256, rgb, SGR
- example: 30 (black), 37 (white), 38;5;226 (yellow)
back - background color, values: empty, 8, 256, rgb, SGR
- example: 40 (black), 47 (white), 48;5;226 (yellow)
text - character set, values: empty, one character, block, list of chars (in order of brightness)
- example: %20 (space), block (keyword for block elements), ox (two chars)

Examples

bash

% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda"
% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&color=256"
% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&back=256&text=%20"
% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&back=8&text=%20%20"
% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&text=helloworld"

yuv4mpegpipe

Raw YUV frame stream with YUV4MPEG header.

text

ffplay http://192.168.1.123:1984/api/stream.y4m?src=camera1

Streaming ingest

shell

ffmpeg -re -i BigBuckBunny.mp4 -c mjpeg -f mpjpeg http://localhost:1984/api/stream.mjpeg?dst=camera1

Overview (`internal/mp4/README.md`)

MP4

This module provides several features:

MSE stream (fMP4 over WebSocket)
Camera snapshots in MP4 format (single frame), can be sent to Telegram
HTTP progressive streaming (MP4 file stream) - bad format for streaming because of high start delay. This format doesn't work in all Safari browsers, but go2rtc will automatically redirect it to HLS/fMP4 in this case.

API examples

MP4 snapshot: http://192.168.1.123:1984/api/frame.mp4?src=camera1 (H264, H265)
MP4 stream: http://192.168.1.123:1984/api/stream.mp4?src=camera1 (H264, H265, AAC)
MP4 file: http://192.168.1.123:1984/api/stream.mp4?src=camera1 (H264, H265*, AAC, OPUS, MP3, PCMA, PCMU, PCM)
- You can use mp4, mp4=flac and mp4=all param for codec filters
- You can use duration param in seconds (ex. duration=15)
- You can use filename param (ex. filename=record.mp4)
- You can use rotate param with 90, 180 or 270 values
- You can use scale param with positive integer values (ex. scale=4:3)

Snapshot to Telegram

This examples for Home Assistant Telegram Bot integration.

change url to your go2rtc web API (http://localhost:1984/ for most users)
change target to your Telegram chat ID (support list)
change src=camera1 to your stream name from go2rtc config

Important. Snapshot will be near instant for most cameras and many sources, except ffmpeg source. Because it takes a long time for ffmpeg to start streaming with video, even when you use #video=copy. Also the delay can be with cameras that do not start the stream with a keyframe.

Snapshot from H264 or H265 camera

yaml

service: telegram_bot.send_video
data:
  url: http://localhost:1984/api/frame.mp4?src=camera1
  target: 123456789

Record from H264 or H265 camera

Record from service call to the future. Doesn't support loopback.

mp4=flac - adds support PCM audio family
filename=record.mp4 - set name for downloaded file

yaml

service: telegram_bot.send_video
data:
  url: http://localhost:1984/api/stream.mp4?src=camera1&mp4=flac&duration=5&filename=record.mp4  # duration in seconds
  target: 123456789

Snapshot from JPEG or MJPEG camera

This example works via the mjpeg module.

yaml

service: telegram_bot.send_photo
data:
  url: http://localhost:1984/api/frame.jpeg?src=camera1
  target: 123456789

Overview (`internal/mpeg/README.md`)

MPEG

This module provides an HTTP API for:

Streaming output in mpegts format.
Streaming output in adts format.
Streaming ingest in mpegts format.

MPEG-TS Server

shell

ffplay http://localhost:1984/api/stream.ts?src=camera1

ADTS Server

shell

ffplay http://localhost:1984/api/stream.aac?src=camera1

Streaming ingest

shell

ffmpeg -re -i BigBuckBunny.mp4 -c copy -f mpegts http://localhost:1984/api/stream.ts?dst=camera1

Overview (`internal/multitrans/README.md`)

TP-Link MULTITRANS

new in v1.9.14 by @forrestsocool

Two-way audio support for Chinese version of TP-Link cameras.

Configuration

yaml

streams:
  tplink_cam:
    # video uses standard RTSP
    - rtsp://admin:[email protected]:554/stream1
    # two-way audio uses MULTITRANS schema
    - multitrans://admin:[email protected]:554

Useful links

Overview (`internal/nest/README.md`)

Google Nest

new in v1.6.0

For simplicity, it is recommended to connect the Nest/WebRTC camera to the Home Assistant.
But if you can somehow get the below parameters, Nest/WebRTC source will work without Home Assistant.

yaml

streams:
  nest-doorbell: nest:?client_id=***&client_secret=***&refresh_token=***&project_id=***&device_id=***

Overview (`internal/ngrok/README.md`)

ngrok

With the ngrok integration, you can get external access to your streams when your Internet connection is behind a private IP address.

you may need external access for two different things:
- WebRTC streams (tunnel the WebRTC TCP port, e.g. 8555)
- go2rtc web interface (tunnel the API HTTP port, e.g. 1984)
ngrok supports authorization for your web interface
ngrok automatically adds HTTPS to your web interface

The ngrok free subscription has the following limitations:

You can reserve a free domain for serving the web interface, but the TCP address you get will always be random and will change with each restart of the ngrok agent (not a problem for WebRTC streams)
You can forward multiple ports from a single agent, but you can only run one ngrok agent on the free plan

go2rtc will automatically get your external TCP address (if you enable it in the ngrok config) and use it for WebRTC connections (if you enable it in the WebRTC config).

You need to manually download the ngrok agent for your OS and register with the ngrok service.

Tunnel for only WebRTC Stream

You need to add your ngrok authtoken and WebRTC TCP port to YAML:

yaml

ngrok:
  command: ngrok tcp 8555 --authtoken eW91IHNoYWxsIG5vdCBwYXNzCnlvdSBzaGFsbCBub3QgcGFzcw

Tunnel for WebRTC and Web interface

You need to create ngrok.yaml config file and add it to the go2rtc config:

yaml

ngrok:
  command: ngrok start --all --config ngrok.yaml

ngrok config example:

yaml

version: "2"
authtoken: eW91IHNoYWxsIG5vdCBwYXNzCnlvdSBzaGFsbCBub3QgcGFzcw
tunnels:
  api:
    addr: 1984  # use the same port as in the go2rtc config
    proto: http
    basic_auth:
      - admin:password  # you can set login/pass for your web interface
  webrtc:
    addr: 8555  # use the same port as in the go2rtc config
    proto: tcp

See the ngrok agent documentation for more details on the ngrok configuration file.

Overview (`internal/onvif/README.md`)

ONVIF

ONVIF Client

new in v1.5.0

The source is not very useful if you already know RTSP and snapshot links for your camera. But it can be useful if you don't.

WebUI > Add webpage supports ONVIF autodiscovery. Your server must be on the same subnet as the camera. If you use Docker, you must use "network host".

yaml

streams:
  dahua1: onvif://admin:[email protected]
  reolink1: onvif://admin:[email protected]:8000
  tapo1: onvif://admin:[email protected]:2020

ONVIF Server

A regular camera has a single video source (GetVideoSources) and two profiles (GetProfiles).

Go2rtc has one video source and one profile per stream.

Tested clients

Go2rtc works as ONVIF server:

Happytime onvif client (windows)
Home Assistant ONVIF integration (linux)
Onvier (android)
ONVIF Device Manager (windows)

PS. Supports only TCP transport for RTSP protocol. UDP and HTTP transports - unsupported yet.

Tested cameras

Go2rtc works as ONVIF client:

Dahua IPC-K42
OpenIPC
Reolink RLC-520A
TP-Link Tapo TC60

Overview (`internal/pinggy/README.md`)

Pinggy

Pinggy - nice service for public tunnels to your local services.

Features:

A free account does not require registration.
It does not require downloading third-party binaries and works over the SSH protocol.
Works with HTTP, TCP and UDP protocols.
Creates HTTPS for your HTTP services.

[!IMPORTANT]
A free account creates a tunnel with a random address that only works for an hour. It is suitable for testing purposes ONLY.

[!CAUTION]
Public access to go2rtc without authorization puts your entire home network at risk. Use with caution.

Why:

It's easy to set up HTTPS for testing two-way audio.
It's easy to check whether external access via WebRTC technology will work.
It's easy to share direct access to your RTSP or HTTP camera with the go2rtc developer. If such access is necessary to debug your problem.

Configuration

You will find public links in the go2rtc log after startup.

Tunnel to go2rtc WebUI.

yaml

pinggy:
  tunnel: http://localhost:1984

Tunnel to RTSP camera.

For example, you have camera: rtsp://admin:[email protected]/cam/realmonitor?channel=1&subtype=0

yaml

pinggy:
  tunnel: tcp://192.168.10.91:554

In go2rtc logs you will get similar output:

text

16:17:43.167 INF [pinggy] proxy url=tcp://abcde-123-123-123-123.a.free.pinggy.link:12345

Now you have a working stream:

text

rtsp://admin:[email protected]:12345/cam/realmonitor?channel=1&subtype=0

Overview (`internal/ring/README.md`)

Ring

new in v1.9.13 by @seydx

This source type supports Ring cameras with two-way audio support.

Configuration

If you have a refresh_token and device_id, you can use them in the go2rtc.yaml config file.

Otherwise, you can use the go2rtc web interface and add your Ring account (WebUI > Add > Ring). Once added, it will list all your Ring cameras.

yaml

streams:
  ring: ring:?device_id=XXX&refresh_token=XXX
  ring_snapshot: ring:?device_id=XXX&refresh_token=XXX&snapshot

Overview (`internal/roborock/README.md`)

Roborock

This source type supports Roborock vacuums with cameras. Known working models:

Roborock S6 MaxV - only video (the vacuum has no microphone)
Roborock S7 MaxV - video and two-way audio
Roborock Qrevo MaxV - video and two-way audio

Configuration

This source supports loading Roborock credentials from the Home Assistant custom integration or the core integration. Otherwise, you need to log in to your Roborock account (MiHome account is not supported). Go to go2rtc WebUI > Add webpage. Copy the roborock://... source for your vacuum and paste it into your go2rtc.yaml config.

If you have a pattern PIN for your vacuum, add it as a numeric PIN (lines: 123, 456, 789) to the end of the roborock link.

Overview (`internal/rtmp/README.md`)

Real-Time Messaging Protocol

This module provides the following features for the RTMP protocol:

Streaming input - RTMP client
Streaming output and ingest in rtmp format - RTMP server
Streaming output and ingest in flv format - FLV server

RTMP Client

You can get a stream from an RTMP server, for example Nginx with nginx-rtmp-module.

Client Configuration

yaml

streams:
  rtmp_stream: rtmp://192.168.1.123/live/camera1

RTMP Server

new in v1.8.0

Streaming output stream in rtmp format:

shell

ffplay rtmp://localhost:1935/camera1

Streaming ingest stream in rtmp format:

shell

ffmpeg -re -i BigBuckBunny.mp4 -c copy -f flv rtmp://localhost:1935/camera1

Server Configuration

By default, the RTMP server is disabled.

yaml

rtmp:
  listen: ":1935"  # by default - disabled!

FLV Server

Streaming output in flv format.

shell

ffplay http://localhost:1984/stream.flv?src=camera1

Streaming ingest in flv format.

shell

ffmpeg -re -i BigBuckBunny.mp4 -c copy -f flv http://localhost:1984/api/stream.flv?dst=camera1

Tested clients

From	To	Comment
go2rtc	Reolink RLC-520A fw. v3.1.0.801	OK

go2rtc.yaml

yaml

streams:
  rtmp-reolink1: rtmp://192.168.10.92/bcs/channel0_main.bcs?channel=0&stream=0&user=admin&password=password
  rtmp-reolink2: rtmp://192.168.10.92/bcs/channel0_sub.bcs?channel=0&stream=1&user=admin&password=password
  rtmp-reolink3: rtmp://192.168.10.92/bcs/channel0_ext.bcs?channel=0&stream=1&user=admin&password=password

Tested server

From	To	Comment
OBS 31.0.2	go2rtc	OK
OpenIPC 2.5.03.02-lite	go2rtc	OK
FFmpeg 6.1	go2rtc	OK
GoPro Black 12	go2rtc	OK, 1080p, 5000kbps

go2rtc.yaml

yaml

rtmp:
  listen: :1935
streams:
  tmp:

OBS

Settings > Stream:

Service: Custom
Server: rtmp://192.168.10.101/tmp
Stream Key: ``
Use auth: <disabled>

OpenIPC

WebUI > Majestic > Settings > Outgoing

Enable
Address: rtmp://192.168.10.101/tmp
Save
Restart

FFmpeg

shell

ffmpeg -re -i bbb.mp4 -c copy -f flv rtmp://192.168.10.101/tmp

GoPro

GoPro Quik > Camera > Translation > Other

Overview (`internal/rtsp/README.md`)

Real Time Streaming Protocol

This module provides the following features for the RTSP protocol:

Streaming input - RTSP client
Streaming output - RTSP server
Streaming ingest
Two-way audio

RTSP Client

Configuration

yaml

streams:
  sonoff_camera: rtsp://rtsp:[email protected]/av_stream/ch0
  dahua_camera:
    - rtsp://admin:[email protected]/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
    - rtsp://admin:[email protected]/cam/realmonitor?channel=1&subtype=1#backchannel=0
  amcrest_doorbell:
    - rtsp://username:[email protected]:554/cam/realmonitor?channel=1&subtype=0#backchannel=0
  unifi_camera: rtspx://192.168.1.123:7441/fD6ouM72bWoFijxK
  glichy_camera: ffmpeg:rtsp://username:[email protected]/live/ch00_1

Recommendations

Amcrest Doorbell users may want to disable two-way audio, because with an active stream, you won't have a working call button. You need to add #backchannel=0 to the end of your RTSP link in YAML config file
Dahua Doorbell users may want to change audio codec for proper two-way audio. Make sure not to request backchannel multiple times by adding #backchannel=0 to other stream sources of the same doorbell. The unicast=true&proto=Onvif is preferred for two-way audio as this makes the doorbell accept multiple codecs for the incoming audio
Reolink users may want NOT to use RTSP protocol at all, some camera models have a very awful, unusable stream implementation
Ubiquiti UniFi users may want to disable HTTPS verification. Use rtspx:// prefix instead of rtsps://. And don't use ?enableSrtp suffix
TP-Link Tapo users may skip login and password, because go2rtc supports login without them
If your camera has two RTSP links, you can add both as sources. This is useful when streams have different codecs, for example AAC audio with main stream and PCMU/PCMA audio with second stream
If the stream from your camera is glitchy, try using ffmpeg source. It will not add CPU load if you don't use transcoding
If the stream from your camera is very glitchy, try to use transcoding with ffmpeg source

Other options

Format: rtsp...#{param1}#{param2}#{param3}

Add custom timeout #timeout=30 (in seconds)
Ignore audio - #media=video or ignore video - #media=audio
Ignore two-way audio API #backchannel=0 - important for some glitchy cameras
Use WebSocket transport #transport=ws...

RTSP over WebSocket

yaml

streams:
  # WebSocket with authorization, RTSP - without
  axis-rtsp-ws:  rtsp://192.168.1.123:4567/axis-media/media.amp?overview=0&camera=1&resolution=1280x720&videoframeskipmode=empty&Axis-Orig-Sw=true#transport=ws://user:[email protected]:4567/rtsp-over-websocket
  # WebSocket without authorization, RTSP - with
  dahua-rtsp-ws: rtsp://user:[email protected]/cam/realmonitor?channel=1&subtype=1&proto=Private3#transport=ws://192.168.1.123/rtspoverwebsocket

RTSP Server

You can get any stream as RTSP-stream: rtsp://192.168.1.123:8554/{stream_name}

You can enable external password protection for your RTSP streams. Password protection is always disabled for localhost calls (ex. FFmpeg or Home Assistant on the same server).

Configuration

yaml

rtsp:
  listen: ":8554"    # RTSP Server TCP port, default - 8554
  username: "admin"  # optional, default - disabled
  password: "pass"   # optional, default - disabled
  default_query: "video&audio"  # optional, default codecs filters

By default go2rtc provide RTSP-stream with only one first video and only one first audio. You can change it with the default_query setting:

default_query: "mp4" - MP4 compatible codecs (H264, H265, AAC)
default_query: "video=all&audio=all" - all tracks from all source (not all players can handle this)
default_query: "video=h264,h265" - only one video track (H264 or H265)
default_query: "video&audio=all" - only one first any video and all audio as separate tracks

Streaming ingest

shell

ffmpeg -re -i BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp rtsp://localhost:8554/camera1

Two-way audio

Before purchasing, it is difficult to understand whether the camera supports two-way audio via the RTSP protocol or not. This isn't usually mentioned in a camera's description. You can only find out by reading reviews from real buyers.

A camera is considered to support two-way audio if it supports the ONVIF Profile T protocol. But in reality, this isn't always the case. And the ONVIF protocol has no connection with the camera's RTSP implementation.

In go2rtc you can find out if the camera supports two-way audio via WebUI > stream probe.

Overview (`internal/srtp/README.md`)

SRTP

This is a support module for the HomeKit module.

[!NOTE]
This module can be removed and its functionality transferred to the homekit module.

Configuration

yaml

srtp:
  listen: :8443  # enabled by default

Overview (`internal/streams/README.md`)

Streams

This core module is responsible for managing the stream list.

Stream to camera

go2rtc supports playing audio files (ex. music or TTS) and live streams (ex. radio) on cameras with two-way audio support.

API example:

text

POST http://localhost:1984/api/streams?dst=camera1&src=ffmpeg:http://example.com/song.mp3#audio=pcma#input=file

you can stream: local files, web files, live streams or any format, supported by FFmpeg
you should use ffmpeg source for transcoding audio to codec, that your camera supports
you can check camera codecs on the go2rtc WebUI info page when the stream is active
some cameras support only low quality PCMA/8000 codec (ex. Tapo)
it is recommended to choose higher quality formats if your camera supports them (ex. PCMA/48000 for some Dahua cameras)
if you play files over http link, you need to add #input=file params for transcoding, so the file will be transcoded and played in real time
if you play live streams, you should skip #input param, because it is already in real time
you can stop active playback by calling the API with the empty src parameter
you will see one active producer and one active consumer in go2rtc WebUI info page during streaming

Publish stream

new in v1.8.0

You can publish any stream to streaming services (YouTube, Telegram, etc.) via RTMP/RTMPS. Important:

Supported codecs: H264 for video and AAC for audio
AAC audio is required for YouTube; videos without audio will not work
You don't need to enable RTMP module listening for this task

You can use the API:

text

POST http://localhost:1984/api/streams?src=camera1&dst=rtmps://...

Or config file:

yaml

publish:
  # publish stream "video_audio_transcode" to Telegram
  video_audio_transcode:
    - rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx
  # publish stream "audio_transcode" to Telegram and YouTube
  audio_transcode:
    - rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx
    - rtmp://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxx

streams:
  video_audio_transcode:
    - ffmpeg:rtsp://user:[email protected]/stream1#video=h264#hardware#audio=aac
  audio_transcode:
    - ffmpeg:rtsp://user:[email protected]/stream1#video=copy#audio=aac

Telegram Desktop App > Any public or private channel or group (where you admin) > Live stream > Start with... > Start streaming.
YouTube > Create > Go live > Stream latency: Ultra low-latency > Copy: Stream URL + Stream key.

Preload stream

new in v1.9.11

You can preload any stream on go2rtc start. This is useful for cameras that take a long time to start up.

yaml

preload:
  camera1:                                     # default: video&audio = ANY
  camera2: "video"                             # preload only video track
  camera3: "video=h264&audio=opus"             # preload H264 video and OPUS audio

streams:
  camera1: 
    - rtsp://192.168.1.100/stream
  camera2: 
    - rtsp://192.168.1.101/stream  
  camera3: 
    - rtsp://192.168.1.102/h265stream
    - ffmpeg:camera3#video=h264#audio=opus#hardware

Examples

text

/* Detailed source-code truncated for AI context efficiency. */

Overview (`internal/tapo/README.md`)

TP-Link Tapo

new in v1.2.0

TP-Link Tapo proprietary camera protocol with two-way audio support.

stream quality is the same as RTSP protocol
use the cloud password, this is not the RTSP password! you do not need to add a login!
you can also use UPPERCASE MD5 hash from your cloud password with admin username
some new camera firmwares require SHA256 instead of MD5

Configuration

yaml

streams:
  # cloud password without username
  camera1: tapo://[email protected]
  # admin username and UPPERCASE MD5 cloud-password hash
  camera2: tapo://admin:[email protected]
  # admin username and UPPERCASE SHA256 cloud-password hash
  camera3: tapo://admin:[email protected]
  # VGA stream (the so called substream, the lower resolution one)
  camera4: tapo://[email protected]?subtype=1 
  # HD stream (default)
  camera5: tapo://[email protected]?subtype=0

bash

echo -n "cloud password" | md5 | awk '{print toupper($0)}'
echo -n "cloud password" | shasum -a 256 | awk '{print toupper($0)}'

TP-Link Kasa

[!NOTE]
This source should be moved to separate module. Because it's source code not related to Tapo.

TP-Link Kasa non-standard protocol more info.

username - urlsafe email, [email protected] -> alex%40gmail.com
password - base64password, secret1 -> c2VjcmV0MQ==

yaml

streams:
  kc401: kasa://username:[email protected]:19443/https/stream/mixed

Tested: KD110, KC200, KC401, KC420WS, EC71.

TP-Link Vigi

new in v1.9.8

TP-Link VIGI cameras. These are cameras from a different sub-brand, but the format is very similar to Tapo. Only the authorization is different. Read more here.

yaml

streams:
  camera1: vigi://admin:{password}@192.168.1.123

Overview (`internal/tuya/README.md`)

Tuya

new in v1.9.13 by @seydx

Tuya is a proprietary camera protocol with two-way audio support. go2rtc supports Tuya Smart API and Tuya Cloud API.

Tuya Smart API (recommended):

Smart Life accounts are NOT supported, you need to create a Tuya Smart account. If the cameras are already added to the Smart Life app, you need to remove them and add them again to the Tuya Smart app.
Cameras can be discovered through the go2rtc web interface via Tuya Smart account (Add > Tuya > Select region and fill in email and password > Login).

Tuya Cloud API:

Requires setting up a cloud project in the Tuya Developer Platform.
Obtain device_id, client_id, client_secret, and uid from Tuya IoT Platform. Here's a guide.
Please ensure that you have subscribed to the IoT Video Live Stream service (Free Trial) in the Tuya Developer Platform, otherwise the stream will not work (Tuya Developer Platform > Service API > Authorize > IoT Video Live Stream).

Configuration

Use the resolution parameter to select the stream (not all cameras support an hd stream through WebRTC even if the camera supports it):

hd - HD stream (default)
sd - SD stream

yaml

streams:
  # Tuya Smart API: WebRTC main stream (use Add > Tuya to discover the URL)
  tuya_main:
    - tuya://protect-us.ismartlife.me?device_id=XXX&email=XXX&password=XXX

  # Tuya Smart API: WebRTC sub stream (use Add > Tuya to discover the URL)
  tuya_sub:
    - tuya://protect-us.ismartlife.me?device_id=XXX&email=XXX&password=XXX&resolution=sd

  # Tuya Cloud API: WebRTC main stream
  tuya_webrtc:
   - tuya://openapi.tuyaus.com?device_id=XXX&uid=XXX&client_id=XXX&client_secret=XXX
  
  # Tuya Cloud API: WebRTC sub stream
  tuya_webrtc_sd:
   - tuya://openapi.tuyaus.com?device_id=XXX&uid=XXX&client_id=XXX&client_secret=XXX&resolution=sd

Overview (`internal/v4l2/README.md`)

Video4Linux

new in v1.9.9

What you should to know about V4L2:

V4L2 (Video for Linux API version 2) works only in Linux
supports USB cameras and other similar devices
one device can only be connected to one software simultaneously
cameras support a fixed list of formats, resolutions and frame rates
basic cameras supports only RAW (non-compressed) pixel formats
regular cameras supports MJPEG format (series of JPEG frames)
advances cameras support H264 format (MSE/MP4, WebRTC compatible)
using MJPEG and H264 formats (if the camera supports them) won't cost you the CPU usage
transcoding RAW format to MJPEG or H264 - will cost you a significant CPU usage
H265 (HEVC) format is also supported (if the camera supports it)

Tests show that the basic Keenetic router with MIPS processor can broadcast three MJPEG cameras in the following resolutions: 1600х1200 + 640х480 + 640х480. The USB bus bandwidth is no more enough for larger resolutions. CPU consumption is no more than 5%.

Supported formats for your camera can be found here: Go2rtc > WebUI > Add > V4L2.

RAW format

Example:

yaml

streams:
  camera1: v4l2:device?video=/dev/video0&input_format=yuyv422&video_size=1280x720&framerate=10

Go2rtc supports built-in transcoding of RAW to MJPEG format. This does not need to be additionally configured.

text

ffplay http://localhost:1984/api/stream.mjpeg?src=camera1

Important. You don't have to transcode the RAW format to transmit it over the network. You can stream it in y4m format, which is perfectly supported by ffmpeg. It won't cost you a CPU usage. But will require high network bandwidth.

text

ffplay http://localhost:1984/api/stream.y4m?src=camera1

Overview (`internal/webrtc/README.md`)

WebRTC

WebRTC Client

This source type supports four connection formats.

Creality

Creality 3D printer camera. Read more here.

yaml

streams:
  creality_k2p: webrtc:http://192.168.1.123:8000/call/webrtc_local#format=creality

go2rtc

This format is only supported in go2rtc. Unlike WHEP, it supports asynchronous WebRTC connections and two-way audio.

yaml

streams:
  webrtc-go2rtc:    webrtc:ws://192.168.1.123:1984/api/ws?src=camera1

Kinesis

new in v1.6.1

Supports Amazon Kinesis Video Streams, using WebRTC protocol. You need to specify the signaling WebSocket URL with all credentials in query params, client_id and ice_servers list in JSON format.

yaml

streams:
  webrtc-kinesis:   webrtc:wss://...amazonaws.com/?...#format=kinesis#client_id=...#ice_servers=[{...},{...}]

PS. For kinesis sources, you can use echo to get connection params using bash, python or any other script language.

OpenIPC

Cameras on open-source OpenIPC firmware.

yaml

streams:
  webrtc-openipc:   webrtc:ws://192.168.1.123/webrtc_ws#format=openipc#ice_servers=[{"urls":"stun:stun.kinesisvideo.eu-north-1.amazonaws.com:443"}]

SwitchBot

Support connection to SwitchBot cameras that are based on Kinesis Video Streams. Specifically, this includes Pan/Tilt Cam Plus 2K and Pan/Tilt Cam Plus 3K and Smart Video Doorbell. Outdoor Spotlight Cam 1080P, Outdoor Spotlight Cam 2K, Pan/Tilt Cam, Pan/Tilt Cam 2K, Indoor Cam are based on Tuya, so this feature is not available.

yaml

streams:
  webrtc-switchbot: webrtc:wss://...amazonaws.com/?...#format=switchbot#resolution=hd#play_type=0#client_id=...#ice_servers=[{...},{...}]

WHEP

WebRTC/WHEP is replaced by WebRTC/WISH standard for WebRTC video/audio viewers. But it may already be supported in some third-party software. It is supported in go2rtc.

yaml

streams:
  webrtc-whep:      webrtc:http://192.168.1.123:1984/api/webrtc?src=camera1

Wyze

new in v1.6.1

Legacy method to connect to Wyze cameras using WebRTC protocol via docker-wyze-bridge. For native P2P support without docker-wyze-bridge, see Source: Wyze.

yaml

streams:
  webrtc-wyze:      webrtc:http://192.168.1.123:5000/signaling/camera1?kvs#format=wyze

WebRTC Server

What you should know about WebRTC:

It's almost always a direct peer-to-peer connection from your browser to the go2rtc app
When you use Home Assistant, Frigate, Nginx, Nabu Casa, Cloudflare, and other software, they are only involved in establishing the connection; they are not involved in transferring media data
WebRTC media cannot be transferred inside an HTTP connection
Usually, WebRTC uses random UDP ports on the client and server to establish a connection
Usually, WebRTC uses public STUN servers to establish a connection outside the LAN; these servers are only needed to establish a connection and are not involved in data transfer
Usually, WebRTC will automatically discover all of your local and public addresses and try to establish a connection

If an external connection via STUN is used:

Uses UDP hole punching technology to bypass NAT even if you haven't opened your server to the world
For about 20% of users, the technology will not work because of the Symmetric NAT
UDP is not suitable for transmitting 2K and 4K high bit rate video over open networks because of the high loss rate:
- https://habr.com/ru/companies/flashphoner/articles/480006/
- https://www.youtube.com/watch?v=FXVg2ckuKfs

Configuration suggestions

by default, WebRTC uses both TCP and UDP on port 8555 for connections
you can use this port for external access
you can change the port in YAML config:

yaml

webrtc:
  listen: ":8555"  # address of your local server and port (TCP/UDP)

Static public IP

forward the port 8555 on your router (you can use the same 8555 port or any other as external port)
add your external IP address and external port to the YAML config

yaml

webrtc:
  candidates:
    - 216.58.210.174:8555  # if you have a static public IP address

Dynamic public IP

forward the port 8555 on your router (you can use the same 8555 port or any other as the external port)
add stun word and external port to YAML config
- go2rtc automatically detects your external address with STUN server

yaml

webrtc:
  candidates:
    - stun:8555  # if you have a dynamic public IP address

Hard tech way 1. Own TCP-tunnel

If you have a personal VPS, you can create a TCP tunnel and setup in the same way as "Static public IP". But use your VPS IP address in the YAML config.

Hard tech way 2. Using TURN-server

If you have personal VPS, you can install TURN server (e.g. coturn, config example).

yaml

webrtc:
  ice_servers:
    - urls: [stun:stun.l.google.com:19302]
    - urls: [turn:123.123.123.123:3478]
      username: your_user
      credential: your_pass

Full configuration

Important! This example is not for copy/pasting!

text

/* Detailed source-code truncated for AI context efficiency. */

By default, go2rtc uses a fixed TCP port and fixed UDP ports for each direct WebRTC connection: listen: ":8555".

You can set a fixed TCP port and a random UDP port for all connections: listen: ":8555/tcp".

You can also disable the TCP port and leave only random UDP ports: listen: "".

Configuration filters

Important! By default, go2rtc excludes all Docker-like candidates (172.16.0.0/12). This cannot be disabled.

Filters allow you to exclude unnecessary candidates. Extra candidates don't make your connection worse or better. But the wrong filter settings can break everything. Skip this setting if you don't understand it.

For example, go2rtc is installed on the host system. And there are unnecessary interfaces. You can keep only the relevant via interfaces or ips options. You can also exclude IPv6 candidates if your server supports them but your home network does not.

yaml

webrtc:
  listen: ":8555/tcp"         # use fixed TCP port and random UDP ports
  filters:
    ips: [ 192.168.1.2 ]      # IP-address of your server
    networks: [ udp4, tcp4 ]  # skip IPv6, if it's not supported for you

For example, go2rtc is inside a closed Docker container (e.g. Frigate). You shouldn't filter Docker interfaces; otherwise, go2rtc won't be able to connect anywhere. But you can filter the Docker candidates because no one can connect to them.

yaml

webrtc:
  listen: ":8555"                   # use fixed TCP and UDP ports
  candidates: [ 192.168.1.2:8555 ]  # add manual host candidate (use docker port forwarding)

Streaming ingest

Ingest: Browser

You can turn the browser of any PC or mobile into an IP camera with support for video and two-way audio. Or even broadcast your PC screen:

Create empty stream in the go2rtc.yaml
Go to go2rtc WebUI
Open links page for your stream
Select camera+microphone or display+speaker option
Open webrtc local page (your go2rtc should work over HTTPS!) or share link via WebTorrent technology (work over HTTPS by default)

Ingest: WHIP

You can use OBS Studio or any other broadcast software with WHIP protocol support. This standard has not yet been approved. But you can download OBS Studio dev version:

Settings > Stream > Service: WHIP > http://192.168.1.123:1984/api/webrtc?dst=camera1

Useful links

Overview (`internal/webtorrent/README.md`)

WebTorrent

[!NOTE]
This section needs some improvement.

WebTorrent Client

This source can get a stream from another go2rtc via WebTorrent protocol.

Client Configuration

yaml

streams:
  webtorrent1: webtorrent:?share=huofssuxaty00izc&pwd=k3l2j9djeg8v8r7e

WebTorrent Server