Go WebRTC: Build Real-Time Apps with Pion and Go (2026 Guide)

1graph TD
2    A[Client Browser] -->|WebSocket| B[Go Signaling Server]
3    B -->|Exchange SDP/ICE| C[Pion PeerConnection]
4    C -->|SRTP/SCTP| D[Remote Peer]
5    C -->|RTP| E[Pion SFU]
6    E -->|Forward RTP| F[Other Peers]
7    C -->|ICE| G[STUN/TURN Server]
8

1package main
2
3import (
4    "fmt"
5    "github.com/pion/webrtc/v3"
6)
7
8func main() {
9    config := webrtc.Configuration{
10        ICEServers: []webrtc.ICEServer{
11            {URLs: []string{"stun:stun.l.google.com:19302"}},
12        },
13    }
14    pc, err := webrtc.NewPeerConnection(config)
15    if err != nil {
16        panic(err)
17    }
18    defer pc.Close()
19
20    pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) {
21        fmt.Printf("ICE state: %s\n", state.String())
22    })
23
24    // Create offer, set local description, etc.
25}
26

1package main
2
3import (
4    "log"
5    "net/http"
6    "sync"
7    "github.com/gorilla/websocket"
8)
9
10var upgrader = websocket.Upgrader{}
11var peers = make(map[string]*websocket.Conn)
12var mu sync.Mutex
13
14func handleWebSocket(w http.ResponseWriter, r *http.Request) {
15    conn, _ := upgrader.Upgrade(w, r, nil)
16    defer conn.Close()
17
18    // Register peer
19    peerID := r.URL.Query().Get("id")
20    mu.Lock()
21    peers[peerID] = conn
22    mu.Unlock()
23
24    for {
25        _, msg, err := conn.ReadMessage()
26        if err != nil {
27            break
28        }
29        // Forward to target peer (simplified)
30        targetID := "peer2" // parse from message
31        mu.Lock()
32        if target, ok := peers[targetID]; ok {
33            target.WriteMessage(websocket.TextMessage, msg)
34        }
35        mu.Unlock()
36    }
37}
38
39func main() {
40    http.HandleFunc("/ws", handleWebSocket)
41    log.Fatal(http.ListenAndServe(":8080", nil))
42}
43

1// Create a video track from a local file
2videoTrack, err := webrtc.NewTrackLocalStaticSample(
3    webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8},
4    "video", "pion",
5)
6if err != nil {
7    panic(err)
8}
9
10// Add track to PeerConnection
11rtpSender, err := pc.AddTrack(videoTrack)
12if err != nil {
13    panic(err)
14}
15
16// Read RTP packets from file and write to track
17go func() {
18    // ... read from .ivf file and call videoTrack.WriteSample()
19}()
20

1graph LR
2    A[Camera/Mic] --> B[Capture Module]
3    B --> C[Encoder VP8/Opus]
4    C --> D[RTP Packetizer]
5    D --> E[PeerConnection]
6    E --> F[SRTP Encryption]
7    F --> G[Network]
8

1// OnTrack handler for an SFU
2pc.OnTrack(func(track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
3    // Create a local track to forward
4    localTrack, _ := webrtc.NewTrackLocalStaticRTP(
5        track.Codec().RTPCodecCapability,
6        track.ID(), track.StreamID(),
7    )
8
9    // Add to all other peers in the room
10    for _, peer := range roomPeers {
11        peer.AddTrack(localTrack)
12    }
13
14    // Read RTP packets and write to local track
15    for {
16        rtp, _, err := track.ReadRTP()
17        if err != nil {
18            return
19        }
20        localTrack.WriteRTP(rtp)
21    }
22})
23

1config := webrtc.Configuration{
2    ICEServers: []webrtc.ICEServer{
3        {
4            URLs: []string{"stun:stun.l.google.com:19302"},
5        },
6        {
7            URLs:       []string{"turn:turn.example.com:3478"},
8            Username:   "user",
9            Credential: "password",
10        },
11    },
12}
13