Skip to main content

LiveKit, the heart of video calls

LiveKit is the core component of Hublot for managing real-time audio and video calls. It relies on WebRTC to provide low-latency, reliable, and scalable communications.

In the Hublot architecture, LiveKit is a separate service from the main application:

  • Hublot manages users, permissions, organizations, and business logic.
  • LiveKit focuses exclusively on rooms, participants, and audio/video streams.

This separation lets Hublot remain independent from the RTC engine while ensuring tight and secure integration.

How LiveKit works with Hublot​

The integration relies on a simple and robust model:

  • Hublot authenticates users.
  • Hublot generates LiveKit tokens with the appropriate permissions.
  • Clients connect directly to LiveKit using those tokens.
  • LiveKit notifies Hublot of important events via a webhook.

Hublot therefore keeps a coherent view of call state without directly managing audio/video streams.

The role of the LiveKit webhook​

The LiveKit webhook lets Hublot receive real-time events related to calls.

Typical events include:

  • room creation and closure
  • participant joins and leaves
  • start and end of audio/video sessions
  • incidents or abnormal RTC states

These notifications allow Hublot to:

  • maintain call state in the application
  • trigger user notifications
  • feed logs and audits
  • apply business rules (for example automatic session closure)

Deploying LiveKit​

LiveKit is deployed as a dedicated service, with:

  • its own configuration
  • its API keys
  • and a URL accessible by Hublot and clients

In all cases, LiveKit must be considered a stateful service and exposed in a controlled manner.

Native binary deployment​

LiveKit can be installed directly on the host system using the official binary.

This deployment mode provides:

  • direct integration with the system (systemd, logs, monitoring)
  • explicit network and port configuration
  • clear visibility into the runtime environment

LiveKit then runs as a classic system service, independent from Hublot but driven by it via the API and webhook.

Docker deployment​

LiveKit can also be deployed inside a Docker container.

In this case:

  • the LiveKit binary is encapsulated in a controlled environment
  • configuration is provided via files and environment variables
  • network exposure is defined by the operator based on their context

This mode naturally fits into an already containerized infrastructure.

Configuration required by Hublot​

Whatever the deployment mode, Hublot requires:

  • a reachable LiveKit URL (LIVEKIT_API_HOST)
  • an API Key
  • an API Secret
  • a LiveKit webhook pointing to Hublot

These elements allow Hublot to drive LiveKit and stay synchronized with real call state.

In conclusion​

LiveKit is the video engine of Hublot, while Hublot keeps full control of business logic and security.

The deployment mode choice (binary or Docker) depends on operational practices and infrastructure constraints. In all cases, Hublot is designed to work identically with LiveKit, without dependency on a specific deployment method.