The API

# Install: pip install websockets
import asyncio
import json
import websockets

API_KEY = "your_api_key_here"
URL = "wss://vibevoice.net/api/stream"


async def stream_audio(pcm_chunks):
    """pcm_chunks yields raw int16 PCM bytes, 16 kHz mono."""
    async with websockets.connect(URL) as ws:
        # 1. Authenticate. The key goes in a text frame, not the URL.
        await ws.send(json.dumps({"api_key": API_KEY}))
        ack = json.loads(await ws.recv())
        if ack.get("status") != "authenticated":
            raise RuntimeError(ack)

        # 2. Read transcript pieces while audio is still going out.
        async def reader():
            async for message in ws:
                frame = json.loads(message)
                if frame.get("is_final"):
                    break
                if frame.get("text"):
                    print(frame["text"], end="", flush=True)

        reading = asyncio.create_task(reader())

        # 3. Send audio as binary frames, then close the input explicitly.
        for chunk in pcm_chunks:
            await ws.send(chunk)
        await ws.send("END_STREAM")

        await reading


asyncio.run(stream_audio(my_pcm_source()))

// Streaming client (browser or Node.js)
const API_KEY = 'your_api_key_here';
const socket = new WebSocket('wss://vibevoice.net/api/stream');
socket.binaryType = 'arraybuffer';

let authenticated = false;

socket.onopen = () => {
  // The API key is sent as the first text frame. There is no query-parameter
  // auth: connecting with ?api_key=... will fail the handshake.
  socket.send(JSON.stringify({ api_key: API_KEY }));
};

socket.onmessage = (event) => {
  const frame = JSON.parse(event.data);

  if (!authenticated) {
    if (frame.status !== 'authenticated') throw new Error(frame.message);
    authenticated = true;
    startSendingAudio();   // int16 PCM, 16 kHz mono, as binary frames
    return;
  }

  if (frame.is_final) {
    socket.close();
  } else if (frame.text) {
    process.stdout.write(frame.text);
  }
};

function finish() {
  socket.send('END_STREAM');   // text frame — flushes the buffered tail
}

// Cargo.toml: tokio = { version = "1", features = ["full"] }
//             tokio-tungstenite = "0.20", futures-util = "0.3", serde_json = "1"
use futures_util::{SinkExt, StreamExt};
use serde_json::json;
use tokio_tungstenite::{connect_async, tungstenite::Message};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let (mut ws, _) = connect_async("wss://vibevoice.net/api/stream").await?;

    // 1. Authenticate with a text frame.
    ws.send(Message::Text(json!({ "api_key": "your_api_key_here" }).to_string()))
        .await?;
    match ws.next().await {
        Some(Ok(Message::Text(ack))) if ack.contains("authenticated") => {}
        other => return Err(format!("auth failed: {:?}", other).into()),
    }

    // 2. Audio goes out as binary frames: int16 PCM, 16 kHz, mono.
    for chunk in pcm_chunks() {
        ws.send(Message::Binary(chunk)).await?;
    }
    ws.send(Message::Text("END_STREAM".into())).await?;

    // 3. Collect text until the final marker.
    while let Some(Ok(Message::Text(text))) = ws.next().await {
        let frame: serde_json::Value = serde_json::from_str(&text)?;
        if frame["is_final"].as_bool().unwrap_or(false) {
            break;
        }
        print!("{}", frame["text"].as_str().unwrap_or(""));
    }
    Ok(())
}

# Synchronous batch transcription. WAV only, and the response is plain
# text — not JSON. The only form field read is prompt.
curl -X POST https://vibevoice.net/api/transcribe \
  -H "X-API-Key: your_api_key_here" \
  -F "file=@/path/to/meeting.wav"

# Anything that is not a WAV, or is long enough to be worth queueing, goes
# through the asynchronous job pipeline instead. It accepts mp3, m4a, wav,
# flac, ogg, opus, aac, wma, amr, 3gp, mp4, mov, mkv, avi, webm, mpeg, mpg
# and wmv, and returns immediately with an id to poll.
curl -X POST https://vibevoice.net/api/jobs/submit \
  -H "X-API-Key: your_api_key_here" \
  -F "file=@/path/to/interview.m4a" \
  -F "include_timestamps=true"

curl -H "X-API-Key: your_api_key_here" \
  https://vibevoice.net/api/jobs/1234