API reference

Every endpoint, WebSocket command, and event. Full machine-readable spec at /v1/openapi.json.

Base URL & auth

All REST endpoints live at https://kardocloud.com/v1. Every request needs a Bearer token in Authorization:

• Server-to-server: Authorization: Bearer kl_live_<your api key>
• Logged-in user (dashboard): Authorization: Bearer <tenant JWT from /auth/login>

Some endpoints (/me/channels/token, /me/sessions/:id/token) accept either.

Projects & API keys

Channels (chat)

Channel messages

Streams (RTMP/HLS)

Sessions

Calls (1:1)

Push devices & credentials

Recordings

Webhooks (registration)

WebSocket protocol — chat

URL: wss://chat.kardocloud.com/v1/chat/socket?room=<channelId>&token=<jwt>

Envelope: { "type": <command|event>, "data": <payload> }

Client → server commands

chat.send         { id?, body, parentId?, mentions?, attachments? }
chat.edit         { id, body }                            (author only)
chat.delete       { id }
read.mark         { upTo? }
typing.start      {}
typing.stop       {}
reaction.add      { messageId?, emoji }
reaction.remove   { messageId?, emoji }
poll.create       { question, options[], durationSec }   (host)
poll.vote         { pollId, optionIdx }
poll.close        { pollId }                              (host)
qa.ask            { body }
qa.upvote         { qaId }
qa.answer         { qaId, body }                          (host)
gift.send         { kind, amountCents, recipientId? }
superchat.send    { body, amountCents, currency }
mod.timeout       { userId, durationSec }                 (host)
mod.ban / unban   { userId }                              (host)
mod.mute / unmute { userId }                              (host)
mod.delete        { messageId }                           (host)
mod.slowmode      { onSec }                               (host)
mod.bannedwords   { words[] }                             (host)

Server → client events

welcome           { you, room, viewers, slowmode, bannedWords[] }
chat              { id, authorId, authorName, body, parentId?, at }
chat.edited       { id, body, at, by }
chat.deleted      { id, by }
read              { userId, name, upTo }
typing            { userId, name, on }
reaction          { messageId?, emoji, count }
poll              { id, question, options[], state, endsAt? }
qa                { id, authorName, body, upvotes, answer? }
gift              { senderId, kind, amountCents, at }
superchat         { id, senderId, body, amountCents, currency, pinnedUntil }
mod.action        { kind, target?, by, reason? }
presence          { viewers }
system            { body }
error             { code, message }

WebSocket protocol — SFU

URL: wss://sfu.kardocloud.com/?token=<jwt>&room=<sessionId or streamId>

JSON-RPC 2.0-like:

// client → server
{ "id": "1", "type": "request", "method": "getRouterRtpCapabilities", "params": {} }
// server → client (reply)
{ "id": "1", "type": "response", "result": { "rtpCapabilities": {...} } }
// or error
{ "id": "1", "type": "response", "error": { "msg": "..." } }
// server → client (push notify)
{ "type": "notify", "method": "new-producer", "params": { peerId, producerId, kind } }

RPC methods

getRouterRtpCapabilities()
join({ rtpCapabilities, displayName })
createWebRtcTransport({ direction: 'send' | 'recv' })
connectTransport({ transportId, dtlsParameters })
produce({ transportId, kind, rtpParameters })
consume({ producerId, rtpCapabilities })
resumeConsumer({ consumerId })

Notifications

peer-joined      { peerId, displayName }
peer-left        { peerId }
new-producer     { peerId, producerId, kind }
producer-closed  { producerId }

Use mediasoup-client to handle the heavy lifting — see React quickstart.

WHIP / WHEP HTTP

Body: SDP offer (Content-Type: application/sdp). Response: SDP answer + Location header for the resource.

Machine-readable

For codegen: /v1/openapi.json · Swagger UI: /Live/Developer/swagger.

Next

Back to overview →