Streaming

// npm install meetwave-stream      (Node 22 or later, and browsers)
// export MEETWAVE_API_KEY=mwk_...   (your key, from the console)
import { readFile } from "node:fs/promises";
import { connect } from "meetwave-stream";

const session = connect({
  apiKey: process.env.MEETWAVE_API_KEY, tier: "names", language: "en",
});
session.on("ready", () => console.log("Connected, streaming…"));
session.on("final", (final) => {
  console.log(`[${final.start.toFixed(1)} s] ${final.text}`);
});

const audio = await readFile("meeting.pcm"); // 16 kHz mono 16-bit PCM
for (let at = 0; at < audio.length; at += 3200) {
  // Any size; what is sent before the server is ready is kept for it
  session.send(audio.subarray(at, at + 3200));
  await new Promise((resolve) => setTimeout(resolve, 100));
}
const { transcript } = await session.stop(); // waits for the full transcript
for (const segment of transcript.segments) {
  console.log(segment.speaker, segment.text);
}

// Node 22 or later, run as an .mjs file
// export MEETWAVE_API_KEY=mwk_...   (your key, from the console)
// Turn any recording into 16 kHz mono PCM first:
//   ffmpeg -i meeting.mp3 -f s16le -ac 1 -ar 16000 meeting.pcm
import { readFile } from "node:fs/promises";

const headers = { Authorization: `Bearer ${process.env.MEETWAVE_API_KEY}` };
const FRAME = 3200; // 100 ms of 16 kHz 16-bit mono audio
const MIN_FRAME = 640; // 20 ms: the shortest frame the server takes
const CONFIG = {
  type: "config", tier: "text", language: "en",
  encoding: "pcm_s16le", sample_rate: 16000,
};
const audio = await readFile("meeting.pcm");
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
let transcriptionId = null;

const socket = new WebSocket("wss://stream.meetwave.io/v1/stream", { headers });
socket.onopen = () => socket.send(JSON.stringify(CONFIG));

socket.onmessage = async (event) => {
  const message = JSON.parse(event.data);
  if (message.type === "ready") {
    console.log("Connected, streaming…");
    for (let at = 0; audio.length - at >= MIN_FRAME; at += FRAME) {
      socket.send(audio.subarray(at, at + FRAME));
      await sleep(100); // real-time pace, as a microphone would send
    }
    socket.send('{"type": "stop"}');
  } else if (message.type === "partial") {
    process.stdout.write(`\r… ${message.text}`);
  } else if (message.type === "final") {
    console.log(`\r[${message.start.toFixed(1)} s] ${message.text}`);
  } else if (message.type === "error") {
    console.error(`${message.code}: ${message.message}`);
  } else if (message.type === "stopped") {
    transcriptionId = message.transcript_id;
  }
};

socket.onclose = async (event) => {
  if (transcriptionId === null) {
    throw new Error(`Closed with ${event.code} before the end`);
  }
  // The full transcript: at once for English text, in minutes for other tiers and languages
  const url = `https://api.meetwave.io/v1/transcriptions/${transcriptionId}`;
  let transcription = await (await fetch(url, { headers })).json();
  while (transcription.status === "queued" || transcription.status === "processing") {
    await sleep(5000);
    transcription = await (await fetch(url, { headers })).json();
  }
  console.log(transcription.status, transcriptionId);
};

import os
import requests
from flask import Flask

app = Flask(__name__)


# Serve this only to your own signed-in users
@app.post("/stream-token")
def stream_token():
    response = requests.post(
        "https://api.meetwave.io/v1/stream/tokens",
        headers={"Authorization": f"Bearer {os.environ['MEETWAVE_API_KEY']}"},
    )
    return response.json(), response.status_code

import express from "express";

const app = express();

// Serve this only to your own signed-in users
app.post("/stream-token", async (req, res) => {
  const response = await fetch("https://api.meetwave.io/v1/stream/tokens", {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.MEETWAVE_API_KEY}` },
  });
  res.status(response.status).json(await response.json());
});

app.listen(3000);