Local API

import requests

TOKEN = "YOUR_TOKEN"
BASE = "http://localhost:7849"
HEADERS = {
    "Authorization": f"Bearer {TOKEN}",
    "Content-Type": "application/json"
}

# Say something
requests.post(f"{BASE}/speak", json={
    "text": "Hello from Python!"
}, headers=HEADERS)

# Choose a voice and add emotion
requests.post(f"{BASE}/speak", json={
    "text": "This is incredible!",
    "voice": "vivian",
    "direction": "excited and happy"
}, headers=HEADERS)

# Use a cloned voice
requests.post(f"{BASE}/speak", json={
    "text": "Has anyone seen Patrick?",
    "voice": "Spongebob"
}, headers=HEADERS)

# Wait for playback to finish
response = requests.post(f"{BASE}/speak", json={
    "text": "Waiting until I finish.",
    "wait": True
}, headers=HEADERS, timeout=70)
print(response.json())

# List all voices
voices = requests.get(f"{BASE}/voices", headers=HEADERS).json()
for v in voices:
    print(f"{v['name']} ({v['type']})")

# OpenAI SDK: one-shot TTS to a WAV file
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_TOKEN",
    base_url="http://127.0.0.1:7849/v1",
)

audio = client.audio.speech.create(
    model="speaklone",
    voice="aiden",
    input="Hello from local Speaklone.",
    response_format="wav",
)

with open("speech.wav", "wb") as f:
    f.write(audio.read())

# Streaming TTS: iterate raw chunked WAV bytes (audio/wav)
import requests

with requests.post(
    "http://127.0.0.1:7849/v1/audio/speech",
    headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
    json={
        "model": "speaklone",
        "input": "Streaming hello from Speaklone.",
        "response_format": "wav",
        "stream": True,
    },
    stream=True,
) as r:
    with open("stream.wav", "wb") as f:
        for chunk in r.iter_content(chunk_size=4096):
            if chunk:
                f.write(chunk)

# Speech-to-text via multipart
with open("speech.wav", "rb") as f:
    r = requests.post(
        f"{BASE}/v1/audio/transcriptions",
        headers={"Authorization": f"Bearer {TOKEN}"},
        files={"file": f},
        data={"model": "speaklone-asr"},
    )
print(r.json()["text"])

const TOKEN = "YOUR_TOKEN";
const BASE = "http://localhost:7849";
const HEADERS = {
  "Authorization": `Bearer ${TOKEN}`,
  "Content-Type": "application/json"
};

// Say something
await fetch(`${BASE}/speak`, {
  method: "POST",
  headers: HEADERS,
  body: JSON.stringify({ text: "Hello from JavaScript!" })
});

// Choose a voice and add emotion
await fetch(`${BASE}/speak`, {
  method: "POST",
  headers: HEADERS,
  body: JSON.stringify({
    text: "This is incredible!",
    voice: "vivian",
    direction: "excited and happy"
  })
});

// Use a cloned voice
await fetch(`${BASE}/speak`, {
  method: "POST",
  headers: HEADERS,
  body: JSON.stringify({
    text: "Has anyone seen Patrick?",
    voice: "Spongebob"
  })
});

// Wait for playback to finish
const res = await fetch(`${BASE}/speak`, {
  method: "POST",
  headers: HEADERS,
  body: JSON.stringify({
    text: "Waiting until I finish.",
    wait: true
  })
});
console.log(await res.json());

// List all voices
const voices = await fetch(`${BASE}/voices`, {
  headers: { "Authorization": `Bearer ${TOKEN}` }
}).then(r => r.json());
voices.forEach(v => console.log(`${v.name} (${v.type})`));

// One-shot TTS via the OpenAI SDK
import OpenAI from "openai";
import fs from "node:fs";

const client = new OpenAI({
  baseURL: "http://127.0.0.1:7849/v1",
  apiKey: TOKEN,
});

const speech = await client.audio.speech.create({
  model: "speaklone",
  voice: "aiden",
  input: "Hello from Speaklone.",
  response_format: "wav",
});

fs.writeFileSync("speech.wav", Buffer.from(await speech.arrayBuffer()));

// Streaming TTS: stream raw WAV bytes straight to a file
import fs from "node:fs";
import { Readable } from "node:stream";

const res = await fetch(`${BASE}/v1/audio/speech`, {
  method: "POST",
  headers: HEADERS,
  body: JSON.stringify({
    model: "speaklone",
    input: "Streaming hello from Speaklone.",
    response_format: "wav",
    stream: true,
  }),
});

// res.headers.get("content-type") === "audio/wav"
await new Promise((resolve, reject) => {
  Readable.fromWeb(res.body)
    .pipe(fs.createWriteStream("stream.wav"))
    .on("finish", resolve)
    .on("error", reject);
});

// Speech-to-text via multipart
const form = new FormData();
form.append("file", new Blob([fs.readFileSync("speech.wav")]), "speech.wav");
form.append("model", "speaklone-asr");

const stt = await fetch(`${BASE}/v1/audio/transcriptions`, {
  method: "POST",
  headers: { "Authorization": `Bearer ${TOKEN}` },
  body: form,
}).then(r => r.json());

console.log(stt.text);