C++ client SDK for LiveKit

Use this SDK to add realtime video, audio and data features to your C++ app. By connecting to LiveKit Cloud or a self-hosted server, you can quickly build applications such as multimodal AI, live streaming, or video calls with just a few lines of code.

Docs

Using the SDK

CMake (≥ 3.20) is used for building the SDK itself and for consuming it as a library. The cpp-example-collection contains a reference LiveKitSDK.cmake which downloads the latest stable release at CMake configure time. See docs/building.md for additional documentation on integrating LiveKit into your project.

To build the SDK from source:

git clone --recurse-submodules https://github.com/livekit/client-sdk-cpp.git
cd client-sdk-cpp
./build.sh release  # or .\build.cmd release on Windows

Building requires a stable Rust toolchain and platform-specific build deps (protobuf, abseil, openssl on Linux). See docs/building.md for full prerequisites table, Docker recipe, CMake presets, and troubleshooting.

Hello, LiveKit

Here is a minimal example of the main function for sending and receiving video and data track frames. The sender plays the role of a robot or camera, publishing video and data track frames every 100 ms; the receiver stands in for the cloud service or operator UI, logging every frame it sees. In a production system the synthetic video would be a robot's perception output and the data track would carry sensor readings or operator commands, but the connection and publishing pattern is the same. Full source for both processes lives in the cpp-example-collection repo.

The sender creates tracks and publishes data.

Initialize LiveKit and connect to the room

#include "livekit/livekit.h"
 
// Get your url and token from env vars, args, etc.
const std::string url = "wss://hello.livekit.cloud";
const std::string token = "sender_token";
 
// Start the LiveKit SDK before creating rooms or tracks.
livekit::initialize(livekit::LogLevel::Info);
 
// Set your room options, here we will use defaults.
livekit::RoomOptions options;
 
// Create the room & connect to the room using a server URL and participant token.
auto room = std::make_unique<livekit::Room>();
if (!room->connect(url, token, options)) {
  std::cerr << "Failed to connect to LiveKit\n";
  return 1;
}

Create the VideoSource, which provides frames to the VideoTrack, then create and publish the VideoTrack

// Get the local participant to create tracks.
auto participant = room->localParticipant().lock();
if (!participant)
{
  std::cerr << "Unable to get the local participant!" << std::endl;
  return 1;
}
 
// Publish a synthetic camera track named "camera0" backed by a VideoSource.
auto video_source = std::make_shared<livekit::VideoSource>(640, 480);
auto video_track = participant->publishVideoTrack("camera0", video_source, livekit::TrackSource::SOURCE_CAMERA);
if (!video_track) {
  std::cerr << "Failed to publish video track\n";
  return 1;
}

Create and publish the DataTrack

// Publish a data track named "app-data" for app messages.
auto data_track_result = participant->publishDataTrack("app-data");
if (!data_track_result) {
  std::cerr << "Failed to publish data track\n";
  return 1;
}
auto data_track = data_track_result.value();
 
// Release the participant to reduce scope.
participant.reset();

Publish video and data track frames every 100ms

int count = 0;
 
while (true)
{
  // Create a 640x480 RGBA video frame.
  auto vf = livekit::VideoFrame::create(640, 480, livekit::VideoBufferType::RGBA);
 
  // Capture the frame. This publishes the frame on VideoTrack camera0.
  video_source->captureFrame(vf);
 
  const std::string message = "hello #" + std::to_string(count);
  const auto now_microsec =
        std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
 
  // Create and push stamped DataTrackFrame.
  const livekit::DataTrackFrame frame{
        std::vector<std::uint8_t>(message.begin(), message.end()),
        now_microsec,
        };
 
  // Optionally, capture the result.
  auto push_result = data_track->tryPush(frame);
  if (!push_result) {
    const auto& error = push_result.error();
    std::cerr << "[warn] Failed to push data frame: code=" << static_cast<std::uint32_t>(error.code)
              << " message=" << error.message << "\n";
  }
 
  ++count;
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

The receiver side setup is the same, except now we set callbacks to the relevant tracks.

Initialize LiveKit and Connect to the room

#include "livekit/livekit.h"
 
// Get your url and token from env vars, args, etc.
const std::string url = "wss://hello.livekit.cloud";
const std::string token = "receiver_token";
 
// Start the LiveKit SDK before creating rooms or tracks.
livekit::initialize(livekit::LogLevel::Info);
 
// Set your room options, here we use the defaults.
livekit::RoomOptions options;
 
// Create the room & connect to the room using a server URL and participant token.
auto room = std::make_unique<livekit::Room>();
if (!room->connect(url, token, options)) {
  std::cerr << "Failed to connect to LiveKit\n";
  return 1;
}

Set callbacks for new video and data frames

// The identity of the participant sending video and data frames.
const std::string sender_identity = "sender_identity";
 
// Set the callback for new video frames from the sender's "camera0" VideoTrack.
room->setOnVideoFrameCallback(sender_identity, "camera0", [](const livekit::VideoFrame& frame, std::int64_t) {
  std::cout << "video frame: " << frame.width() << "x" << frame.height() << "\n";
});
 
// Set the callback for new frames on the sender's "app-data" DataTrack.
room->addOnDataFrameCallback(sender_identity, "app-data",
                             [](const std::vector<std::uint8_t>& payload, std::optional<std::uint64_t>) {
                               const std::string message(payload.begin(), payload.end());
                               std::cout << "data message: " << message << "\n";
                             });

For end-to-end samples and a fuller set of demos, see the cpp-example-collection repo.

Features

Connect to LiveKit rooms (Cloud or self-hosted)
Receive remote audio/video tracks
Publish local audio/video tracks
Data tracks (low-level) and data streams (high-level)
RPC between participants
End-to-end encryption (E2EE)
Hardware-accelerated codecs (via the underlying Rust SDK)
Chromium-style tracing for performance debugging

Supported platforms: Linux (x64, arm64), macOS (12.3+, Apple Silicon & Intel), Windows (x64).

Logging & tracing

The SDK uses a thin public logging API in <livekit/logging.h> with both compile-time and runtime filtering. Plug your own sink in (file, JSON, syslog, ROS2 RCLCPP_*) via setLogCallback. See docs/logging.md.

Chromium-format performance traces can be captured with startTracing / stopTracing and viewed in chrome://tracing or ui.perfetto.dev. See docs/tracing.md.

Testing

Integration and stress test suites live under src/tests/. Build them with ./build.sh debug-tests, point LIVEKIT_URL + two participant tokens at a local livekit-server --dev, and run via ctest or directly. See docs/testing.md.

Developer tools

clang-tidy, clang-format, valgrind, and Doxygen are all wired up via scripts under scripts/. Set up the pre-commit auto-formatter with:

./scripts/install-pre-commit.sh

See docs/tools.md.

Deprecation

Future deprecations and deprecation dates will be listed here for the next major release.

<tt>v1.0.0</tt>

>NOTE: With the official 1.0.0 release we have introduced breaking changes to previous unofficial versions in order to align with other LiveKit client SDKs. See the v1.0.0 release notes for the full list of changes.

Contributing

PRs welcome. Issues: https://github.com/livekit/client-sdk-cpp/issues.

LiveKit Ecosystem
Agents SDKs	Python · Node.js
LiveKit SDKs	Browser · Swift · Android · Flutter · React Native · Rust · Node.js · Python · Unity · Unity (WebGL) · ESP32 · C++
Starter Apps	Python Agent · TypeScript Agent · React App · SwiftUI App · Android App · Flutter App · React Native App · Web Embed
UI Components	React · Android Compose · SwiftUI · Flutter
Server APIs	Node.js · Golang · Ruby · Java/Kotlin · Python · Rust · PHP (community) · .NET (community)
Resources	Docs · Docs MCP Server · CLI · LiveKit Cloud
LiveKit Server OSS	LiveKit server · Egress · Ingress · SIP
Community	Developer Community · Slack · X · YouTube