Live Transcription

pip install camb-sdk

npm install @camb-ai/sdk node-record-lpcm16

npm install @camb-ai/sdk

import asyncio
import os

from camb.client import CambAI
from camb.live_transcription import Microphone, ServerMessageType

async def main():
    client = CambAI(api_key=os.environ["CAMB_API_KEY"])
    session = await client.live_transcription.connect(
        model="boli-v5",
        language="en-us",
        sample_rate=16000,
    )

    @session.on(ServerMessageType.RESULTS)
    def _(msg):
        text = msg.transcript.strip()
        if not text:
            return
        # Interim frames refine the current utterance; print them as they
        # arrive. On is_final the utterance is done — commit it on its own
        # line so the next utterance starts fresh instead of overwriting it.
        if not msg.is_final:
            print(f"[Interim] {text}\n", end="", flush=True)
        else:
            print(f"\r\033[K{text}\n", end="", flush=True)

    @session.on(ServerMessageType.CLOSED)
    def _(info):
        print(f"\nClosed code={info.code}")

    async with session:
        mic = Microphone(sample_rate=16000, chunk_size=1600)
        await session.stream_audio(mic)

asyncio.run(main())

import { CambClient, Microphone, ServerMessageType } from "@camb-ai/sdk";

const client = new CambClient({ apiKey: process.env.CAMB_API_KEY });

const session = await client.liveTranscription.connect({
    model: "boli-v5",
    language: "en-us",
    sampleRate: 16000,
});

session.on(ServerMessageType.Results, (msg) => {
    const text = msg.transcript.trim();
    if (!text) return;
    // Interim frames print as they arrive; commit the final on its own
    // line so the next utterance starts fresh instead of overwriting it.
    if (!msg.isFinal) {
        process.stdout.write(`[Interim] ${text}\n`);
    } else {
        process.stdout.write(`\r\x1b[K${text}\n`);
    }
});

const mic = Microphone.fromNode({ sampleRate: 16000 });
await mic.start();
await session.pipe(mic);

import { CambClient, Microphone, ServerMessageType } from "@camb-ai/sdk";

const client = new CambClient({ apiKey: API_KEY });

const session = await client.liveTranscription.connect({
    model: "boli-v5",
    language: "en-us",
});

// Keep finalized utterances; show the in-progress one live beneath them.
let committed = "";
session.on(ServerMessageType.Results, (msg) => {
    const text = msg.transcript.trim();
    const caption = document.getElementById("caption");
    if (msg.isFinal) {
        committed += (committed ? "\n" : "") + text;
        caption.innerText = committed;
    } else {
        caption.innerText = committed ? `${committed}\n${text}` : text;
    }
});

const mic = await Microphone.fromBrowser({ sampleRate: 16000 });
await mic.start();
await session.pipe(mic);

{ "type": "Ready" }

{
  "type": "Results",
  "is_final": true,
  "start": 0.0,
  "duration": 1.24,
  "channel": {
    "alternatives": [{
      "transcript": "hello world",
      "confidence": 0.92,
      "words": [
        { "word": "hello", "start": 0.0, "end": 0.42, "confidence": 0.95 },
        { "word": "world", "start": 0.42, "end": 1.10, "confidence": 0.89 }
      ]
    }]
  },
  "metadata": {
    "request_id": "...",
    "model_info": { "name": "boli-v5", "version": "1.2.0" }
  }
}

{
  "type": "Results",
  "is_final": false,
  "channel": {
    "alternatives": [{ "transcript": "hello wor", "words": [] }]
  }
}

{ "type": "Error", "code": "invalid_encoding", "message": "Unsupported encoding 'opus'" }

{ "type": "Closed", "code": 1000, "reason": "" }

@session.on(ServerMessageType.RESULTS)
def on_results(msg):
    # msg.is_final → interim refinement (False) vs finalized utterance (True)
    print(msg.is_final, msg.transcript, msg.words)

@session.on(ServerMessageType.ERROR)
def on_error(err):
    print(err.code, err.message)

# Forward-compat: receive every event including new ones added later.
@session.on_any
def on_any(event_type, payload):
    print(event_type, payload)

session.on(ServerMessageType.Results, (msg) => {
    // msg.isFinal → interim refinement (false) vs finalized utterance (true)
    console.log(msg.isFinal, msg.transcript, msg.words);
});

session.on(ServerMessageType.Error, (err) => {
    console.error(err.code, err.message);
});

session.onAny((event, payload) => {
    console.log(event, payload);
});

session = await client.live_transcription.connect(
    model="boli-v5-transcribe",
    language="pt-br",
    encoding="linear16",
    sample_rate=48000,
    channels=1,
)

const session = await client.liveTranscription.connect({
    model: "boli-v5-transcribe",
    language: "pt-br",
    encoding: "linear16",
    sampleRate: 48000,
    channels: 1,
});

await session.keep_alive()

await session.keepAlive();