Non-streaming synthesis

curl -X POST https://tts.navana.ai/tts/bytes \
  -H "X-API-Key: $BODHI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "आपके खाते में पाँच हज़ार रुपये हैं।",
    "lang": "hi",
    "output_format": "8000:pcm16"
  }' \
  --output speech.pcm --dump-header -

import os, wave, requests

response = requests.post(
    "https://tts.navana.ai/tts/bytes",
    headers={
        "X-API-Key": os.environ["BODHI_API_KEY"],
        "Content-Type": "application/json",
    },
    json={
        "text": "आपके खाते में पाँच हज़ार रुपये हैं।",
        "lang": "hi",
        "output_format": "8000:pcm16",
    },
    timeout=120,
)
response.raise_for_status()

rate = int(response.headers["X-Sample-Rate"])

# Raw PCM is not playable on its own, so wrap it in a WAV container.
with wave.open("speech.wav", "wb") as f:
    f.setnchannels(1)
    f.setsampwidth(2)
    f.setframerate(rate)
    f.writeframes(response.content)

const res = await fetch('https://tts.navana.ai/tts/bytes', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.BODHI_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    text: 'आपके खाते में पाँच हज़ार रुपये हैं।',
    lang: 'hi',
    output_format: '8000:pcm16',
  }),
})
if (!res.ok) throw new Error(await res.text())

const pcm = new Uint8Array(await res.arrayBuffer())
const sampleRate = Number(res.headers.get('X-Sample-Rate'))

package main

import (
	"bytes"
	"encoding/binary"
	"encoding/json"
	"io"
	"net/http"
	"os"
	"strconv"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"text":          "आपके खाते में पाँच हज़ार रुपये हैं।",
		"lang":          "hi",
		"output_format": "8000:pcm16",
	})

	req, _ := http.NewRequest(http.MethodPost,
		"https://tts.navana.ai/tts/bytes", bytes.NewReader(body))
	req.Header.Set("X-API-Key", os.Getenv("BODHI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	pcm, _ := io.ReadAll(resp.Body)
	rate, _ := strconv.Atoi(resp.Header.Get("X-Sample-Rate"))

	// The body is raw PCM. Wrap it before anything can play it.
	if err := writeWAV("speech.wav", pcm, rate); err != nil {
		panic(err)
	}
}

// writeWAV prepends the 44-byte canonical header for 16-bit mono PCM.
func writeWAV(path string, pcm []byte, sampleRate int) error {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer f.Close()

	var h bytes.Buffer
	h.WriteString("RIFF")
	binary.Write(&h, binary.LittleEndian, uint32(36+len(pcm)))
	h.WriteString("WAVEfmt ")
	binary.Write(&h, binary.LittleEndian, uint32(16))           // fmt chunk size
	binary.Write(&h, binary.LittleEndian, uint16(1))            // PCM
	binary.Write(&h, binary.LittleEndian, uint16(1))            // mono
	binary.Write(&h, binary.LittleEndian, uint32(sampleRate))   // sample rate
	binary.Write(&h, binary.LittleEndian, uint32(sampleRate*2)) // byte rate
	binary.Write(&h, binary.LittleEndian, uint16(2))            // block align
	binary.Write(&h, binary.LittleEndian, uint16(16))           // bits per sample
	h.WriteString("data")
	binary.Write(&h, binary.LittleEndian, uint32(len(pcm)))

	if _, err := f.Write(h.Bytes()); err != nil {
		return err
	}
	_, err = f.Write(pcm)
	return err
}