← RESEARCH
EVAL / 2026.09 MEDIA RESEARCH

Nimble Live Streaming

A live-streaming service built on the licensed Nimble Streamer core: SRT / RTMP / WHIP ingest → ABR transcode → LL-HLS/HLS/DASH over a CDN, with DVR/timeshift. Research (2026-09-08), POC pending.

Nimble StreamerSRTRTMPWHIPLL-HLSDASH

Why

The surrounding platform already runs a CDN and VOD tooling (HLS packaging, AES keyfiles). The missing piece is a complete live media server: one that accepts contribution feeds, normalizes and transcodes them into an ABR ladder, packages HLS/LL-HLS/DASH, and records DVR. The product goal is a commercial Live Streaming service sold alongside the existing CDN/VOD ecosystem, built without writing a media server from scratch.

Three paths exist: build in-house (Rust/C over nginx-rtmp and ffmpeg), adopt open source (SRS, MediaMTX, OvenMediaEngine), or license Nimble Streamer from Softvelum. Building in-house costs many person-months and carries feature risk on LL-HLS, DRM, and SRT. Open source avoids license fees but lacks a commercial-grade integrated transcoder and DRM, and still demands heavy integration work. Nimble offers a mature media server with the full protocol set and paid addons (Transcoder, DRM, DVR, Advertizer) at low per-server cost, with centralized administration through the WMSPanel control plane.

This research exists to validate Nimble as the commercial core and to resolve the license and billing angle: Nimble bills per instance (roughly $50/month per instance, or a lower tier near $20 for five servers), and the Transcoder, DRM, and Advertizer addons carry separate fees. The operator packages license plus infrastructure plus CDN bandwidth into a resold service, which makes per-instance variable cost, WMSPanel control-plane lock-in, and margin against self-run open source the decisive commercial questions.

Scope

  • Ingest: SRT (packet-loss resilience for remote contribution over the Internet), RTMP (OBS/encoder compatibility), WHIP/WebRTC (low-latency browser ingest).
  • Delivery: LL-HLS for low latency, HLS/DASH for broad compatibility, pushed through the CDN edge. Nimble acts as origin/packager; the CDN serves as edge cache over existing PoPs.
  • Transcoding: Nimble Live Transcoder building an ABR ladder (1080p/720p/480p/360p) from a single source, with GPU (NVENC) versus CPU (x264) evaluated on stream density, quality, and transcoder license cost.
  • DVR / timeshift: DVR recording and nDVR timeshift playback over HLS/DASH, with a storage backend decision (local NVMe versus S3/MinIO object storage) and retention policy.
  • Whitelabel integration: exposing the service under the operator’s own brand so end customers never see Softvelum or WMSPanel, driven by a custom console over the Nimble and WMSPanel APIs.

Problems & Solutions

Branded delivery without exposing the vendor

Nimble/WMSPanel separates into three layers. The data plane (ingest, delivery, player) is already whitelabel-ready: URLs sit on the operator’s own domains and viewers see no Softvelum branding. Reporting supports WMSPanel white-label stats pulled into the console. Only the control-plane dashboard carries Softvelum branding, and that is exactly what the operator replaces with its own React console calling the APIs behind the scenes.

Driving Nimble from a custom console

Three APIs cover the control surface. The WMSPanel Control API (cloud) writes config: applications, ingest interfaces, DVR, routes, transcoder. The Nimble Native API (:8082/manage/) reads config and runtime state and performs stream routing. The WMSPanel Pull API returns viewer and bandwidth statistics with white-label support. Lab testing on 2026-09-08 (Ubuntu 24.04, Nimble 4.3.3) confirmed the Native API end to end: live_streams_status, srt_receiver_stats, DVR operations, and a POST /manage/rtmp/republish that provisioned an egress route and returned status: Ok. Per-tenant provisioning (data slice, publish key, route) runs through the APIs; ingest interfaces and applications are provisioned once per server through the dashboard.

Control-plane dependency and cost

The Control API runs only through WMSPanel cloud and requires internet access, so it does not function on an isolated network. When WMSPanel is unreachable the instances keep streaming (the data plane is independent) but config cannot change. Both the Control API and Pull API require a paid subscription to enable client_id/api_key, so the whitelabel control plane is a paid tier from day one; the Native API is free and ran under trial. The Pull API caps at 15k calls/day, which the console absorbs by caching stats. The recommended control-plane path is the Control API for full addon access; direct /etc/nimble config generation remains a fallback for air-gapped operation at the cost of the paid addons and a stream-interrupting restart.

Architecture

G cluster_origin Nimble Origin (operator PoP) encoder Encoder / OBS / Camera streamer Nimble Streamer encoder->streamer SRT / RTMP / WHIP cdn CDN Edge viewers Viewers cdn->viewers transcoder Live Transcoder (ABR ladder) streamer->transcoder dvr DVR / nDVR storage streamer->dvr packager Packager HLS / LL-HLS / DASH transcoder->packager packager->cdn pull / push console Operator Console (React, custom brand) controlapi WMSPanel Control API console->controlapi provision nativeapi Nimble Native API :8082 console->nativeapi runtime pullapi WMSPanel Pull API (white-label stats) console->pullapi stats controlapi->streamer nativeapi->streamer

Contribution feeds arrive over SRT, RTMP, or WHIP. The Nimble origin transcodes them into an ABR ladder, packages HLS/LL-HLS/DASH, and records DVR. The CDN edge distributes to viewers over the operator’s own URLs. The custom console provisions through the Control API and reads runtime and statistics through the Native and Pull APIs, keeping all vendor branding out of the customer’s view.