Timestamps

curl https://api.boson.ai/v1/audio/speech \
  -H "Authorization: Bearer $BOSON_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "higgs-tts-3",
    "input": "The quick brown fox jumps over the lazy dog.",
    "response_format": "wav",
    "timestamps": true
  }' > response.json

jq -r '.audio' response.json | base64 -d > out.wav
jq -r '.timestamps[] | "\(.start_ms)-\(.end_ms) ms  \(.text)"' response.json

import base64
import os
import requests

resp = requests.post(
    "https://api.boson.ai/v1/audio/speech",
    headers={"Authorization": f"Bearer {os.environ['BOSON_API_KEY']}"},
    json={
        "model": "higgs-tts-3",
        "input": "The quick brown fox jumps over the lazy dog.",
        "response_format": "wav",
        "timestamps": True,
    },
)
resp.raise_for_status()
body = resp.json()

with open("out.wav", "wb") as f:
    f.write(base64.b64decode(body["audio"]))

for entry in body["timestamps"]:
    print(f"{entry['start_ms']}-{entry['end_ms']} ms  {entry['text']}")

import { writeFile } from "node:fs/promises";

const res = await fetch("https://api.boson.ai/v1/audio/speech", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.BOSON_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "higgs-tts-3",
    input: "The quick brown fox jumps over the lazy dog.",
    response_format: "wav",
    timestamps: true,
  }),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);

const body = await res.json();
await writeFile("out.wav", Buffer.from(body.audio, "base64"));

for (const entry of body.timestamps) {
  console.log(`${entry.start_ms}-${entry.end_ms} ms  ${entry.text}`);
}

import base64
import json
import os
import requests

entries = {}  # index -> latest copy of the entry

with requests.post(
    "https://api.boson.ai/v1/audio/speech",
    headers={"Authorization": f"Bearer {os.environ['BOSON_API_KEY']}"},
    json={
        "model": "higgs-tts-3",
        "input": "The quick brown fox jumps over the lazy dog.",
        "response_format": "pcm",
        "stream": True,
        "timestamps": True,
    },
    stream=True,
) as resp, open("out.pcm", "wb") as f:
    resp.raise_for_status()
    for line in resp.iter_lines(decode_unicode=True):
        if not line.startswith("data: "):
            continue
        payload = line[len("data: "):]
        if payload == "[DONE]":
            break
        event = json.loads(payload)
        if "audio" in event:
            f.write(base64.b64decode(event["audio"]["data"]))
        for entry in event.get("timestamps", []):
            entries[entry["index"]] = entry

for entry in sorted(entries.values(), key=lambda e: e["index"]):
    print(f"{entry['start_ms']}-{entry['end_ms']} ms  {entry['text']}")

import { createWriteStream } from "node:fs";

const res = await fetch("https://api.boson.ai/v1/audio/speech", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.BOSON_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "higgs-tts-3",
    input: "The quick brown fox jumps over the lazy dog.",
    response_format: "pcm",
    stream: true,
    timestamps: true,
  }),
});
if (!res.ok || !res.body) throw new Error(`${res.status}: ${await res.text()}`);

const out = createWriteStream("out.pcm");
const entries = new Map<number, any>(); // index -> latest copy of the entry
const decoder = new TextDecoder();
let buffer = "";

for await (const chunk of res.body) {
  buffer += decoder.decode(chunk, { stream: true });
  let end;
  while ((end = buffer.indexOf("\n\n")) !== -1) {
    const line = buffer.slice(0, end);
    buffer = buffer.slice(end + 2);
    if (!line.startsWith("data: ")) continue;
    const payload = line.slice("data: ".length);
    if (payload === "[DONE]") continue;
    const event = JSON.parse(payload);
    if (event.audio) out.write(Buffer.from(event.audio.data, "base64"));
    for (const entry of event.timestamps ?? []) entries.set(entry.index, entry);
  }
}
out.end();

for (const entry of [...entries.values()].sort((a, b) => a.index - b.index)) {
  console.log(`${entry.start_ms}-${entry.end_ms} ms  ${entry.text}`);
}