Transcription

curl -sS -X POST https://platform.modulate.ai/api/velma-2-stt-batch \
  -H "X-API-Key: $MODULATE_API_KEY" \
  -F "upload_file=@audio.mp3" \
  -F "speaker_diarization=true" \
  -F "emotion_signal=true" \
  -F "accent_signal=true" \
| jq -r 'if .detail then "error: \(.detail)" else
    .text, (.utterances[]
    | "  [\(.start_ms)ms] Speaker \(.speaker) (\(.language)) \(.emotion)/\(.accent): \(.text)")
  end'

import os, requests

response = requests.post(
    "https://platform.modulate.ai/api/velma-2-stt-batch",
    headers={"X-API-Key": os.environ["MODULATE_API_KEY"]},
    data={
        "speaker_diarization": "true",
        "emotion_signal": "true",
        "accent_signal": "true",
    },
    files={"upload_file": open("audio.mp3", "rb")},
)
response.raise_for_status()
result = response.json()

print(result["text"])
for u in result["utterances"]:
    print(f"  [{u['start_ms']}ms] Speaker {u['speaker']} ({u['language']}) "
          f"{u['emotion']}/{u['accent']}: {u['text']}")

import fs from "fs";
import FormData from "form-data";

const form = new FormData();
form.append("upload_file", fs.createReadStream("audio.mp3"), { filename: "audio.mp3" });
form.append("speaker_diarization", "true");
form.append("emotion_signal", "true");
form.append("accent_signal", "true");

const response = await fetch("https://platform.modulate.ai/api/velma-2-stt-batch", {
  method: "POST",
  headers: { "X-API-Key": process.env.MODULATE_API_KEY, ...form.getHeaders() },
  body: form,
});

const result = await response.json();

if (!response.ok) {
  console.error(`error: ${result.detail}`);
  process.exit(1);
}

console.log(result.text);
for (const u of result.utterances) {
  console.log(
    `  [${u.start_ms}ms] Speaker ${u.speaker} (${u.language}) ` +
    `${u.emotion}/${u.accent}: ${u.text}`
  );
}

import os, asyncio, json, websockets

API_KEY = os.environ["MODULATE_API_KEY"]
AUDIO_FILE = "audio.mp3"
CHUNK_SIZE = 4096

async def stream():
    url = (
        f"wss://platform.modulate.ai/api/velma-2-stt-streaming"
        f"?api_key={API_KEY}&speaker_diarization=true"
    )
    async with websockets.connect(url) as ws:
        async def send():
            with open(AUDIO_FILE, "rb") as f:
                while chunk := f.read(CHUNK_SIZE):
                    await ws.send(chunk)
            await ws.send("")  # end of stream

        async def receive():
            async for message in ws:
                msg = json.loads(message)
                if msg["type"] == "utterance":
                    u = msg["utterance"]
                    print(f"  [{u['start_ms']}ms] Speaker {u['speaker']} ({u['language']}): {u['text']}")
                elif msg["type"] == "done":
                    print(f"done: {msg['duration_ms']}ms of audio")
                    break
                elif msg["type"] == "error":
                    raise RuntimeError(msg["error"])

        await asyncio.gather(send(), receive())

asyncio.run(stream())

import { WebSocket } from "ws";
import { createReadStream } from "fs";

const url =
  `wss://platform.modulate.ai/api/velma-2-stt-streaming` +
  `?api_key=${process.env.MODULATE_API_KEY}&speaker_diarization=true`;

const ws = new WebSocket(url);

ws.on("open", () => {
  const stream = createReadStream("audio.mp3", { highWaterMark: 4096 });
  stream.on("data", (chunk) => ws.send(chunk));
  stream.on("end", () => ws.send(""));
});

ws.on("message", (data) => {
  const msg = JSON.parse(data);
  if (msg.type === "utterance") {
    const u = msg.utterance;
    console.log(`  [${u.start_ms}ms] Speaker ${u.speaker} (${u.language}): ${u.text}`);
  } else if (msg.type === "done") {
    console.log(`done: ${msg.duration_ms}ms of audio`);
    ws.close();
  } else if (msg.type === "error") {
    console.error(`error: ${msg.error}`);
  }
});

// A rejected handshake closes without sending an error frame first.
ws.on("close", (code) => {
  if (code !== 1000) console.error(`error: connection closed ${code}`);
});
ws.on("error", (err) => console.error(`error: ${err.message}`));

curl -sS -X POST https://platform.modulate.ai/api/velma-2-stt-batch-english-vfast \
  -H "X-API-Key: $MODULATE_API_KEY" \
  -F "upload_file=@audio.mp3" \
  -F "time_stamps=true" \
  -F "speaker_diarization=true" \
| jq -r 'if .detail then "error: \(.detail)" else
    .text,
    (.utterances[]? | "  [\(.start_ms)ms] Speaker \(.speaker): \(.text)"),
    (.words[:5][]? | "  \(.start)s - \(.end)s  \(.word)")
  end'

import os, requests

response = requests.post(
    "https://platform.modulate.ai/api/velma-2-stt-batch-english-vfast",
    headers={"X-API-Key": os.environ["MODULATE_API_KEY"]},
    data={"time_stamps": "true", "speaker_diarization": "true"},
    files={"upload_file": open("audio.mp3", "rb")},
)
response.raise_for_status()
result = response.json()

print(result["text"])

for u in result.get("utterances", []):
    print(f"  [{u['start_ms']}ms] Speaker {u['speaker']}: {u['text']}")

# words[] times are seconds; utterances[] times are milliseconds
for w in result.get("words", [])[:5]:
    print(f"  {w['start']}s - {w['end']}s  {w['word']}")

import asyncio, json, os, websockets

API_KEY = os.environ["MODULATE_API_KEY"]
AUDIO_FILE = "audio.ogg"
CHUNK_SIZE = 8192

async def transcribe():
    url = (
        f"wss://platform.modulate.ai/api/velma-2-stt-streaming-english-v2"
        f"?api_key={API_KEY}&audio_format=ogg&endpointing=true"
    )
    async with websockets.connect(url, max_size=None) as ws:
        async def send():
            with open(AUDIO_FILE, "rb") as f:
                while chunk := f.read(CHUNK_SIZE):
                    await ws.send(chunk)
            await ws.send("")  # end of stream

        send_task = asyncio.create_task(send())
        try:
            async for message in ws:
                msg = json.loads(message)
                if msg["type"] == "partial_utterance":
                    # Replace the displayed partial, do not append.
                    print(f"\r[partial] {msg['partial_utterance']['text']}", end="", flush=True)
                elif msg["type"] == "utterance":
                    print(f"\n[final]   {msg['utterance']['text']}")
                elif msg["type"] == "done":
                    print(f"\ndone: {msg['duration_ms']}ms of audio")
                    break
                elif msg["type"] == "error":
                    raise RuntimeError(msg["error"])
        finally:
            if not send_task.done():
                send_task.cancel()

asyncio.run(transcribe())

curl -sS -X POST https://platform.modulate.ai/api/velma-2-stt-batch-multilingual-vfast \
  -H "X-API-Key: $MODULATE_API_KEY" \
  -F "upload_file=@audio.mp3" \
  -F "language=es" \
| jq -r 'if .detail then "error: \(.detail)" else
    "[\(.language)] \(.text)"
  end'

import os, requests

response = requests.post(
    "https://platform.modulate.ai/api/velma-2-stt-batch-multilingual-vfast",
    headers={"X-API-Key": os.environ["MODULATE_API_KEY"]},
    data={"language": "es"},
    files={"upload_file": open("audio.mp3", "rb")},
)
response.raise_for_status()
result = response.json()
print(f"[{result['language']}] {result['text']}")