Live streams

Limits and usage

Every stream says live or record and what it sends; Kymoscope admits it against your plan. What it costs, your limits, and what is left.

Every stream and every camera says what it sends before it starts. Kymoscope works out what that costs and admits it against your plan and this month's usage, then the sender prints what is left. This page shows what to declare in each sender, how the cost is worked out, and what happens when a limit runs out.

Live or record

A sender does one of two things with each stream, data and video alike:

ModeWhat happens
liveTransmitted only: viewers watch it as it comes. Nothing is kept.
recordTransmitted, and recorded by its sender in files kept within your storage (or the project’s own). Find it in Cloud; see Recording.

The mode has no default: you always write it in the sender. The app no longer starts recordings; under each stream it shows Live only or Records while it streams. A camera can record only when its data stream is declared record too. See Recording.

What you declare

You write the mode; each sender fills in what it already knows: its channels, its rate, and the bytes a second it really puts on the wire (bytes_per_sec). The Python sender, the collector and the plugins work that out themselves; the TypeScript SDK takes it from you.

SenderWhat you write
Python (kymoscope 1.0)LiveStream(API_KEY, "Rig A", mode="live", hz=100, channels=8), or sources=[{"hz": 10, "channels": 2}, ...] for channels at different rates. A camera: add_camera(..., mode="live", quality="720p", fps=30). See Publishing and Cameras.
Collector (1.0)mode: live or mode: record on each entry of streams: (optional trigger: with record). The collector declares each source's rate and channels; set hz: on a source that hands on whatever arrives (files, MQTT, Kafka, UDP, webhooks, python). See Site collector.
AC and LMU pluginsIn KymoscopeLiveTelemetry.ini: Mode=live or record and Hz= (at most the game's rate; the plugin keeps one sample every 1/Hz). With Camera=1: CameraMode, CameraQuality, CameraFps. The plugin counts its channels.
Browser cameraThe /camera page: mode, quality and frames per second. It shows what is left before you start.
TypeScript SDK (0.9)profile in new LivePublisher(options, deps): { mode, hz, channels, bytes_per_sec } for data (liveBytesPerSec works out bytes_per_sec from one message), { mode, quality, fps } for a camera. Both arguments are required: deps is { fetch, WebSocket, now, store }.
Kymoscope MCPYour assistant asks live or record and writes mode in every stream it configures. See Kymoscope MCP.
TypeScript
import { LivePublisher, liveBytesPerSec } from '@kymoscope/sdk'

// One message as you hand it to publisher.send() (your encoder): 50 samples of 100 channels, 20 a second = 1 kHz.
const oneMessage = encodeMyBlock(samples.slice(0, 50))
let saved = null   // what the publisher keeps across restarts (persist it to reuse the stream id and keys)

const publisher = new LivePublisher(
  {
    supabaseUrl: 'https://api.kymoscope.com',
    apiKey,
    name: 'Bench 3',
    kind: 'data',
    profile: { mode: 'record', hz: 1000, channels: 100, bytes_per_sec: liveBytesPerSec(oneMessage.length, 20) },
    onNotice: (n) => console.warn(n.message),   // e.g. recording stopped: storage full
  },
  // Required: how the publisher reaches the network, tells the time, and keeps its keys across restarts.
  {
    fetch, WebSocket, now: () => Date.now(),
    store: { load: async () => saved, save: async (s) => { saved = s } },
  },
)
await publisher.start()
console.log(publisher.usageMessage)           // what was admitted and what is left

Senders from before these versions are refused with a sentence naming the version to install (pip install -U kymoscope, pip install -U kymoscope-collector, the new plugin DLLs).

What it costs

Data. A data stream's bandwidth starts from Hz × (8 + 4 × channels) × 1.1 bytes a second: an 8-byte time and a 4-byte value per channel for each sample, plus 10 % for headers and encryption. A stream with sources at different rates adds them up, source by source.

Each sender also declares bytes_per_sec, what it really sends: every message repeats the channel names and units, columns are padded, and each message is encrypted and framed. Kymoscope counts the larger of the two, and the relay holds the stream to it. Few samples per message and many channels make the real figure the larger one: a game plugin with 97 channels at 100 Hz, 20 messages a second, sends about 83 KB/s (0.66 Mbit/s) where the formula gives 44 KB/s.

ExampleBandwidth
1 kHz × 100 channels1000 × 408 × 1.1 ≈ 449 KB/s ≈ 3.6 Mbit/s
100 Hz × 20 channels100 × 88 × 1.1 ≈ 9.7 KB/s ≈ 78 kbit/s
1 Hz × 2,000 tags1 × 8008 × 1.1 ≈ 8.8 KB/s ≈ 71 kbit/s

Video. A camera's bitrate follows from its quality and frame rate: between 15, 30 and 60 fps it is interpolated, and below 15 fps it scales down in proportion (7 fps at 720p is 1.1 Mbit/s). Senders encode at the bitrate Kymoscope returns. The 360p low copy for small panels and camera walls adds 0.4 Mbit/s; it is never recorded.

QualityMbit/s at 15 / 30 / 60 fps
360p0.4 / 0.7 / 1.0
480p0.9 / 1.5 / 2.2
720p2.4 / 4.0 / 6.0
1080p3.6 / 6.0 / 9.0

A record stream costs the same bandwidth as a live one; it also fills storage at that rate while it sends (3.6 Mbit/s is about 1.6 GB an hour). A collector's cycles: never change a stream's mode.

Your limits

Your personal streams count against your own plan; the streams of an organization's projects count against the organization's plan. The API key decides which: a project's key sends into that project, a personal key a personal stream. Preferences → Usage shows both.

LimitWhat it means
live.streams.concurrent.maxData streams live at once (Enterprise and Team: 5). One collector is usually one stream, whatever it reads.
live.bandwidth_kbpsThe bandwidth of everything you send at once, data and video added up (Free: 128 kbit/s; Pro and Team: 8 Mbit/s; Enterprise: 50 Mbit/s).
live.max_hzThe highest rate each source of a data stream may declare (1 kHz).
live.max_channelsThe most channels each source of a data stream may declare (Enterprise: 500; most plans: 200).
video.camerasCameras live at once; stopped ones don’t count (Enterprise: 4; other plans: none).
video.max_quality, video.max_fpsThe highest quality and frame rate per camera (Enterprise: 1080p at 60 fps).
video.hours_monthHours your cameras may be live this calendar month, added up across cameras (Enterprise: 200).
cloud.recording.gbRecorded data you can keep. In an organization it is per seat (Team and Enterprise: 100 GB per seat; Pro: 10 GB).
video.recording.gbRecorded camera video you can keep, apart from the data (Enterprise: 50 GB).
cloud.recording.daysDays a recording is kept (Team and Enterprise: 90; Pro: 30).

For higher limits for one account or organization, contact us.

When a limit runs out

  • At start: a stream or camera that doesn't fit is refused, and the sender says why, for example "1080p exceeds your plan (max 720p)." or "3.6 Mbit/s doesn't fit: 48 Mbit/s of 50 Mbit/s is in use.". Lower the rate, channels or quality, declare live, or stop another stream. A stream already live is never cut because another one starts.
  • Storage full: recording stops and the stream stays live. Its row in the stream list says "Recording stopped: data storage full (10 GB). Live continues." With When full, delete oldest on for the stream (Preferences → Usage), its oldest files are deleted instead and recording goes on. See Recording.
  • Video hours used up: the cameras stop and the data goes on. Camera panels say "Video limit reached this month". Cameras can start again next month.
  • After a plan ends or drops: recordings the plan no longer covers (no cloud recording, fewer days, less storage) stay as they are for 30 days. The owner gets an email and a notice when that starts and again 7 days before the end; export them from Cloud: Export all makes one ZIP of every recording beyond the plan (MF4 or CSV, a folder per project and stream, and an index), and the notice and the email open it directly. Camera video isn't included. Then they are deleted, the oldest first. If the plan covers them again before that date, nothing is deleted. Keep protects a recording from fewer days, not from a plan without cloud recording or with less storage.
  • Notices: at 80 % and at 100 % of a monthly or storage limit, the account's (or organization's) owner gets a notice in Notices and an email, once per limit and month. The sender writes each stop (recording, cameras) to its log.

See what is left

  • Preferences → Usage in the app: one bar per limit (live bandwidth now, video hours this month, data stored and video stored, with how long recordings are kept), marked from 80 % and when used up, and the per-stream maxima; under Live now, what is live now with its declared profile, for example "Bench 3 · record · 1 kHz × 100 ch · 3.6 Mbit/s". In an organization it shows two groups: Personal, your own plan and your personal streams, and the organization, its plan and its projects' streams.
  • The start line every sender prints when it is admitted:
Shell
Kymoscope: 'Bench 3' admitted (record, 1 kHz × 100 ch = 3.6 Mbit/s). Left: 32 Mbit/s of 50 Mbit/s live · 3.8 GB of 10 GB data storage (≈ 2.3 h of recording at this rate).
Kymoscope: 'Front' admitted (live, 720p 30 fps = 4.4 Mbit/s). Left: 27.6 Mbit/s of 50 Mbit/s live · 80 of 200 video hours this month.
  • Your AI assistant: the Kymoscope MCP's usage tool returns the same, each limit with what is in use.
  • Your code: fetchUsage in @kymoscope/sdk, before starting a stream:
TypeScript
import { fetchUsage } from '@kymoscope/sdk'

const { limits, usage } = await fetchUsage('https://api.kymoscope.com', apiKey)
// limits: { 'live.bandwidth_kbps': 50000, 'video.hours_month': 200, ... } (null: unlimited)
// usage:  { liveKbps, cameraSeconds, dataBytes, videoBytes }
const leftKbps = limits['live.bandwidth_kbps'] == null ? Infinity : limits['live.bandwidth_kbps'] - usage.liveKbps