A Complete Feature Walkthrough of Jitsi Meet, the Open‑Source WebRTC Video Conferencing Platform

Core Features

High‑quality, scalable audio‑video meetings on Web browsers, Android and iOS.

Rich interaction: chat, keyboard shortcuts, screen capture, remote control, virtual backgrounds.

Identity authentication for meeting security.

Meeting recording and real‑time streaming.

SIP client access.

Multi‑language translation via the ./lang configuration directory.

File sharing among participants.

Flexible integration through external APIs.

Core Components and External Dependencies

Core Components

Jitsi Meet

Position: WebRTC‑compatible front‑end (React & React Native).

Role: Provides the user interface and aggregates all meeting functions.

Jitsi Videobridge (JVB)

Position: WebRTC‑compatible server component.

Role: Routes audio‑video streams between participants efficiently.

Jitsi Conference Focus (jicofo)

Position: Server‑side focus component.

Role: Manages media sessions and acts as a load‑balancer for JVB.

Jitsi Gateway to SIP (jigasi)

Position: Server‑side gateway.

Role: Enables SIP clients to join Jitsi Meet conferences.

Jitsi Broadcasting Infrastructure (jibri)

Position: Recording and streaming toolset.

Role: Captures the conference via a headless Chrome instance, encodes with ffmpeg, and outputs files or live streams.

External Dependency Software

Prosody : XMPP server that handles signaling between all components.

Working Principle

The overall architecture follows a three‑layer design: signaling interaction → media routing → feature extensions.

Client (browser or mobile) initiates a meeting request via the Jitsi Meet front‑end.

Prosody receives the signaling request and forwards it to jicofo.

jicofo validates the room, allocates a JVB node, and returns connection parameters.

JVB establishes media routes for each participant.

If a SIP client is needed, jigasi translates SIP calls into Jitsi‑compatible connections.

For recording or streaming, jibri launches a headless Chrome instance, captures the mixed stream, encodes with ffmpeg, and pushes to storage or a streaming platform.

The front‑end maintains global state via React‑Redux and communicates with back‑end through middleware.js.

Connection Types

External connections are classified as:

Audio‑video links between clients (WebRTC peer‑to‑peer or multi‑point).

Links to external services such as cloud storage or streaming platforms.

Core Workflows

Scenario 1: Standard Audio/Video Meeting

Meeting request : Client → Prosody → jicofo.

Resource allocation : jicofo receives a JVB address and conference key, forwards them via Prosody to the client.

Media connection : Client uses the JVB address to establish a WebRTC media session.

Media exchange : Client sends encoded audio/video to JVB; JVB forwards streams to all participants without additional decoding.

Exit : Client → Prosody → jicofo → JVB; resources are released.

Scenario 2: SIP Client Integration

Access request : SIP client → jigasi → Prosody → jicofo.

Resource allocation : jicofo assigns a JVB node and returns connection parameters to jigasi.

Media channel : jigasi establishes a WebRTC connection to JVB, negotiating codecs.

Conference participation : Media flows SIP ↔ jigasi ↔ JVB ↔ regular clients; jigasi performs format conversion in both directions.

Exit : SIP client → jigasi → Prosody → jicofo → JVB; resources are released.

Scenario 3: Meeting Recording and Streaming

Trigger : Client → Prosody → jicofo (record or stream request).

Authorization : jicofo validates permissions and instructs jibri.

Capture : jibri starts a headless Chrome instance, receives a read‑only media link from JVB.

Encode & Deliver : jibri uses ffmpeg to encode to MP4 or RTMP and either uploads to cloud storage (e.g., Dropbox) or pushes to a platform (e.g., YouTube).

Status sync : jibri reports progress to jicofo, which forwards it to the client via Prosody.

Stop & Release : Client stops the task; jicofo tells jibri to terminate, JVB closes the read‑only link, and the client receives a final confirmation.

Iframe API Integration

Integration Capabilities

Event listening: participant join/leave, avatar updates, chat messages, device errors, conference state changes.

Active commands: create/join meetings, mute/unmute, enable/disable video, start/stop recording, file sharing.

Step‑by‑Step Integration

1. Include API Script

<script src="https://meet.jit.si/external_api.js"></script>

2. Create iframe Container

<!-- Container must have width and height for layout -->
<div id="jitsi-container" style="width: 100%; height: 600px;"></div>

3. Initialize API Client

// Initialization configuration
const domain = 'meet.jit.si'; // Jitsi server domain (official or self‑hosted)
const options = {
  roomName: 'my-test-meeting', // custom room name
  width: '100%',
  height: '100%',
  configOverwrite: {
    startWithAudioMuted: false,
    startWithVideoMuted: false,
    enableFileTransfer: true
  },
  interfaceConfigOverwrite: {
    showParticipantsPanel: true
  },
  userInfo: {
    displayName: 'User 1'
  }
};
const container = document.getElementById('jitsi-container');
const api = new JitsiMeetExternalAPI(domain, options, container);

4. Listen to Key Events

// Conference joined
api.on('videoConferenceJoined', () => {
  console.log('Successfully joined the meeting');
});
// Participant joined
api.on('participantJoined', participant => {
  console.log(`Participant ${participant.displayName} joined`);
});
// Device error
api.on('deviceError', error => {
  console.error(`Device error: ${error.message}`);
});
// Conference left
api.on('videoConferenceLeft', () => {
  console.log('Left the meeting');
  api.dispose(); // clean up
});

5. Execute Commands

// Mute audio
api.executeCommand('toggleAudio');
// Disable video
api.executeCommand('toggleVideo');
// Start recording (server must support it)
api.executeCommand('startRecording', {
  mode: 'file', // 'file' or 'stream'
  filePath: '/path/to/save'
});
// Send a chat message
api.executeCommand('sendMessage', {
  to: 'all',
  text: 'Hello, everyone!'
});

Integration Considerations

If using a self‑hosted Jitsi server, replace the domain value with your server’s domain and ensure external API access is enabled.

The browser must support WebRTC (Chrome, Firefox, Edge, etc.).

Access to camera and microphone requires user permission in the host page.

Recording, SIP access, and other advanced features need the corresponding server‑side components (jibri, jigasi) to be pre‑configured.