Self-hosted
real-time voice, video & AI

import { SRTC, CameraPresets, MicPresets } from '@seastart/srtc-web-sdk'

// Initialize
const srtc = new SRTC()

// Join a channel
const channel = await srtc.join(token)

// Subscribe to the remote audio mix
const remoteAudio = await srtc.subscribeRemoteAudioMixTrack()
await remoteAudio.startPlay()

// Open the microphone
const micTrack = srtc.createLocalMicTrack(MicPresets.music)
await micTrack.startCapture()
await srtc.publishLocalTrack(micTrack)

// Open the camera and preview
const cameraTrack = srtc.createLocalCameraTrack(CameraPresets['720p'])
await cameraTrack.startCapture()
cameraTrack.addPlayView(document.querySelector('#local-video')!)
await srtc.publishLocalTrack(cameraTrack)

// Leave the channel
await srtc.leave()

import SRTC

let srtc = SRTC()

// Join a channel
let channel = try await srtc.joinChannel(
    token: token,
    options: JoinOptions(autoSubscribeAudio: true)
)

// Open the microphone
let micTrack = srtc.createLocalMicTrack(preset: .music)
try await micTrack.startCapture()
try await channel.publishLocalTrack(micTrack)

// Open the camera
let cameraTrack = srtc.createLocalCameraTrack(preset: .h720p)
try await cameraTrack.startCapture()
try await channel.publishLocalTrack(cameraTrack)

// Subscribe to remote video (ChannelDelegate callback)
func channel(_ channel: Channel, user: UserInfo, didAddTrack track: TrackInfo) {
    guard track.kind == .video else { return }
    try? await channel.subscribeRemoteVideoTrack(uid: user.uid, trackId: track.id)
}

// Leave the channel
await srtc.leaveChannel()

// Initialize the engine
val rtcEngine = RTCEngine.create(app = application, enableLocalLog = true)
rtcEngine.initSDK()

// Register callbacks
rtcEngine.setRtcClientEvent(object : RTCClientEvent {
    override fun onJoinSucceed(channel: String, uid: String, whiteBoard: String?) {
        // Joined successfully
    }
    override fun onStreamTrackAdd(uid: String, channel: String, trackId: String, trackDesc: String) {
        // A remote track arrived — subscribe to its video here
        val remoteTrack = rtcEngine.getRemoteVideoTrack(uid, trackDesc)
        remoteTrack?.addPlayView(remoteView)
        rtcEngine.subscribeRemoteTrack(uid, trackId, null)
    }
})

// Join a channel
val joinOptions = JoinOptions(autoSubscribeAudio = true, autoSubscribeVideo = true)
rtcEngine.join(activity = this, token = token, options = joinOptions, resultListener = null)

// Open the camera
val cameraTrack = rtcEngine.getLocalCameraTrack(PreOptionCamera._720P)
cameraTrack.addPlayView(previewView)
cameraTrack.startCapture { rtcEngine.publishLocalVideo(track = cameraTrack, ...) }

// Open the microphone
val micTrack = rtcEngine.getLocalMicTrack(PreOptionMic.def)
rtcEngine.publishLocalAudio(track = micTrack, ...)

// Leave and release resources
rtcEngine.leave()
rtcEngine.releaseSDK()

// Initialize the SDK
SRTC::IRTCEngine* _irtc = nullptr;
SRTC::RTCEngine_Init(&_irtc);
_irtc->setEventHandler(this);

// Join a channel
std::string token = "token issued by your server";
_irtc->joinChannel(token);

// Open the camera
SRTC::IRTCLocalCameraTrack* camTrack = nullptr;
_irtc->getCameraTrack("camera", &camTrack);
camTrack->addPlayView(previewView);
camTrack->startCapture();
_irtc->publish(camTrack);

// Open the microphone
SRTC::IRTCLocalMicTrack* micTrack = nullptr;
_irtc->getAudioTrack("mic", &micTrack);
micTrack->startCapture();
_irtc->publish(micTrack);

// Subscribe to remote video (in onStreamTrackAdd)
SRTC::IRTCRemoteVideoTrack* remoteTrack = nullptr;
_irtc->getRemoteVideoTrack(uid, trackId, &remoteTrack);
remoteTrack->addPlayView(hwnd);
_irtc->subscribe(remoteTrack);

// Leave the channel
_irtc->leaveChannel();

import asyncio
import srtc

async def main(token: str):
    # Join and auto-subscribe to everyone’s audio (leaves automatically on exit)
    async with await srtc.Channel.join(token, auto_subscribe_audio=True) as ch:
        print("joined:", ch.info.channel)

        # Publish an audio track: write() takes PCM at any sample rate, paced in real time
        tts = await ch.publish_audio(desc="tts", audio_format=srtc.AudioFormat(24000, 1))

        # Consume remote audio frame by frame (16 kHz mono PCM, tagged by uid)
        async for frame in ch.audio_frames():
            text = await asr.transcribe(frame.pcm)       # your ASR
            if text:
                await tts.write(await llm_tts(text))     # Play the LLM + TTS reply back into the channel

asyncio.run(main("<token issued by your server>"))