Jitsi Meet: Self-Hosted Open-Source Video Conferencing

What Jitsi Meet Is and Who It Serves

Jitsi Meet is a complete video conferencing system: the web application, mobile clients, and server components together form a platform for HD audio and video meetings. Unlike proprietary conferencing tools, Jitsi Meet can be deployed on infrastructure you control, and the source code is Apache-2.0 licensed.

The public instance at meet.jit.si is free to use and requires only a Google, Facebook, or GitHub account to start a meeting. Self-hosting targets organizations with data residency requirements, enterprises that need custom branding, and developers integrating video into their own applications through the SDK.

The web client supports all current browsers without plugins. Mobile apps are available for Android (Google Play and F-Droid) and iOS (App Store). The README lists HD audio and video, content sharing, raise hand and reactions, chat with private conversations, polls, and virtual backgrounds as built-in features.

Architecture: Videobridge, XMPP, and the Web App

Jitsi Meet is a set of Open Source projects, as the README states explicitly. The web application in this repository is one component. A complete self-hosted deployment requires several other components:

- Jitsi Videobridge (JVB): the WebRTC media server that routes audio and video between participants. It runs as a separate process. - Prosody: an XMPP server used for signaling and room management. - Jicofo: the conference focus component that coordinates sessions. - The web app itself, which is served by a web server (nginx by default in the Debian package).

The web application is a TypeScript React application. The `conference.js` file is the central orchestration module. The `react/` directory holds the main React components. The `modules/` directory contains non-React utility modules. Native mobile functionality is in the `android/` and `ios/` directories, and the `react-native-sdk/` directory contains the React Native SDK.

All media transmission uses WebRTC. The `lib-jitsi-meet` npm package, listed in `package.json`, provides the core WebRTC abstraction layer.

Self-Hosting Jitsi Meet: Debian and Docker

The README points to the handbook at jitsi.github.io/handbook for the full deployment guide. Jitsi Meet provides two supported deployment paths for self-hosting:

Debian packages: the handbook's devops guide covers installing Jitsi Meet on Debian or Ubuntu. The `debian/` directory in the repository contains the package metadata. Debian packages are the primary production deployment method and handle service management, nginx configuration, and initial certificate setup.

Docker: the Makefile shows deploy targets that reference a Docker-based deployment setup. The handbook documents a comprehensive Docker setup described as designed to make deployments as simple as possible.

Building from source requires the Node.js ecosystem. The `Makefile` runs `webpack` with `NODE_OPTIONS=--max-old-space-size=4096` for the TypeScript compilation step, which requires significant memory. The `package.json` defines a `compile` target that runs TypeScript type checking before the webpack build.

The handbook at jitsi.github.io/handbook/docs/releases tracks stable releases. The current stable release is 2.0.11248, published on 2026-09-14.

Embedding Jitsi Meet in Your Application

The Web SDK and React Native SDK allow embedding video conferencing into existing applications. The `react-native-sdk/` directory contains the React Native implementation. The SDK provides a component that renders a Jitsi Meet conference within your application's view hierarchy.

The `config.js` file at the root of the web application is the primary configuration surface. It controls server URLs, feature flags, UI options, and security settings. The `interface_config.js` file controls the UI appearance. Both files are documented for self-hosters who want to customize their deployment.

For developers who want to embed video without managing their own server infrastructure, JaaS (8x8 Jitsi as a Service) provides an API. The README describes JaaS as allowing developers, organizations, and businesses to build and deploy video solutions using Jitsi running on 8x8's global platform. The JaaS endpoint is jaas.8x8.vc.

Security and End-to-End Encryption

Jitsi Meet's security model has two layers. Transport security: all traffic between clients and the Jitsi Videobridge uses DTLS-SRTP, which is standard WebRTC media security. Signaling uses TLS.

End-to-End Encryption (E2EE) is an optional layer that prevents the Jitsi Videobridge from decrypting media. With E2EE enabled, the media is encrypted by the sender's browser before it reaches the videobridge, and decrypted by each recipient's browser. The E2EE implementation is documented in a whitepaper at jitsi.org/e2ee-whitepaper/. The README links to jitsi.org/security for a comprehensive description of all security aspects.

E2EE with a Selective Forwarding Unit (SFU) like Jitsi Videobridge uses Insertable Streams, a WebRTC API. Not all browsers support Insertable Streams, so E2EE is not universally available across all supported platforms. The security documentation describes which scenarios support full E2EE and which provide only transport security.

Limitations: Operational Complexity and Browser Support Caveats

Self-hosting Jitsi Meet is more complex than deploying a single-container application. A production deployment requires Jitsi Videobridge, Prosody (XMPP), Jicofo, nginx, and the web app itself, all coordinated. The Debian package automates much of this, but debugging issues across five components requires familiarity with each.

The virtual backgrounds feature depends on TensorFlow.js and MediaPipe for background segmentation. The Makefile includes deploy targets for `deploy-mediapipe-segmentation`, `deploy-meet-models`, `deploy-tf-wasm`, and `deploy-tflite`. These are large files that must be served alongside the web application; the total deployment footprint is significantly larger than a minimal web app.

The Makefile's `compile` target runs TypeScript type checking before building. TypeScript errors block the build, which is the correct behavior for production, but requires that developers run `npm run tsc:web` before attempting a build when they change TypeScript files. The `NODE_OPTIONS=--max-old-space-size=4096` flag indicates that the build process requires at least 4 GB of heap memory.

Jitsi Meet versus Zoom and Google Meet

Zoom and Google Meet are the dominant proprietary video conferencing platforms. Both are hosted-only services with per-seat pricing for advanced features. Jitsi Meet differs in three ways: it is open source and self-hostable, it requires no account at all for participants joining a room on meet.jit.si, and it has no per-seat licensing cost when self-hosted.

The trade-offs are real. Zoom and Google Meet provide polished mobile and desktop experiences maintained by large engineering teams, with features like live transcription, breakout rooms, and enterprise directory integration. Jitsi Meet's mobile apps are available but the README acknowledges they are maintained separately from the web client. Self-hosting also removes the simplicity of using a managed service: platform maintenance, scaling, and certificate management become the deployer's responsibility.

For teams that need data sovereignty or cannot use external conferencing services due to compliance requirements, Jitsi Meet is the practical open-source option. For teams that just need video calls and have no self-hosting requirement, the managed platforms require less operational work.

Editorial conclusion

Jitsi Meet is the right choice for organizations that need a self-hosted video conferencing platform with no per-user licensing cost and full control over data residency. The handbook at jitsi.github.io/handbook describes the full devops deployment guide. A self-hosted instance requires maintaining a Jitsi Videobridge for media routing and an XMPP server (Prosody), which adds operational complexity beyond running the web application alone. Teams that need branded video experiences without managing that infrastructure can use JaaS (8x8 Jitsi as a Service), which the README describes as providing the same Jitsi platform on 8x8's global infrastructure. The last push to the repository was on 2026-09-22, and the current stable release is 2.0.11248 from 2026-09-14.

Frequently asked questions

Official sources

1. jitsi/jitsi-meet on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases