TTS in five minutes

Generate a WAV file with one authenticated request to Rime’s text-to-speech API. Choose a language tab, copy the complete script, and run it from your terminal.

Prerequisites

You need:

A Rime API token: Create a free Rime account and copy your API key from the API Tokens page.
A language runtime, depending on which tab you follow:
- cURL: a terminal with cURL installed (included with macOS and most Linux distributions).
- Python: Python 3.10 or later.
- JavaScript: Node.js 18 or later.
- TypeScript: Node.js 18+ plus tsx (npm install -g tsx).

Each code block is tabbed by language. Pick the same language in every block.

These examples call Rime’s HTTPS API with a standard library or built-in fetch. Rime does not publish an npm or PyPI SDK. Framework-specific starters are available for Next.js, Vite, Express, plain Node, and FastAPI.

Copy the request

Create a file called rime_hello_world.py, rime_hello_world.js, or rime_hello_world.ts (or run the cURL version directly in your terminal) and paste the full script:

Full script (copy/paste)

curl --request POST \
  --url https://users.rime.ai/v1/rime-tts \
  --header 'Authorization: Bearer your_api_key_here' \
  --header 'Content-Type: application/json' \
  --header 'Accept: audio/wav' \
  --output output.wav \
  --data '{
    "text": "Hello! This is Rime speaking.",
    "speaker": "celeste",
    "modelId": "coda"
  }'

import json
import urllib.request

RIME_API_KEY = "your_api_key_here"

headers = {
    "Accept": "audio/wav",
    "Authorization": f"Bearer {RIME_API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "text": "Hello! This is Rime speaking.",
    "speaker": "celeste",
    "modelId": "coda"
}

data = json.dumps(payload).encode("utf-8")

request = urllib.request.Request(
    "https://users.rime.ai/v1/rime-tts",
    data=data,
    headers=headers,
    method="POST"
)

with urllib.request.urlopen(request) as response:
    with open("output.wav", "wb") as f:
        while chunk := response.read(4096):
            f.write(chunk)

print("Audio saved to output.wav")

const fs = require("fs");

const RIME_API_KEY = "your_api_key_here";

const headers = {
    "Accept": "audio/wav",
    "Authorization": `Bearer ${RIME_API_KEY}`,
    "Content-Type": "application/json"
};

const payload = {
    text: "Hello! This is Rime speaking.",
    speaker: "celeste",
    modelId: "coda"
};

async function generateSpeech() {
    const response = await fetch("https://users.rime.ai/v1/rime-tts", {
        method: "POST",
        headers: headers,
        body: JSON.stringify(payload)
    });

    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    fs.writeFileSync("output.wav", Buffer.from(buffer));
    console.log("Audio saved to output.wav");
}

generateSpeech();

import * as fs from "fs";

const RIME_API_KEY: string = "your_api_key_here";

const headers: Record<string, string> = {
    "Accept": "audio/wav",
    "Authorization": `Bearer ${RIME_API_KEY}`,
    "Content-Type": "application/json"
};

const payload = {
    text: "Hello! This is Rime speaking.",
    speaker: "celeste",
    modelId: "coda"
};

async function generateSpeech(): Promise<void> {
    const response = await fetch("https://users.rime.ai/v1/rime-tts", {
        method: "POST",
        headers: headers,
        body: JSON.stringify(payload)
    });

    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    fs.writeFileSync("output.wav", Buffer.from(buffer));
    console.log("Audio saved to output.wav");
}

generateSpeech();

Run it

The cURL tab runs the request directly. For Python, JavaScript, or TypeScript, run:

python rime_hello_world.py

node rime_hello_world.js

npx tsx rime_hello_world.ts

A successful request writes output.wav and prints:

Audio saved to output.wav

Confirm it worked

A 200 and a file on disk are not proof of success. Two things produce both without producing audio:

cURL writes error bodies to the file. The example above uses --output output.wav without --fail, so a rejected request leaves a small text file named output.wav containing the error message.
An unrecognized Accept header returns JSON rather than audio. Rime falls back to a 200 response whose body is JSON with an audioContent field. The file is not empty and the status is not an error, but no player will open it.

Check the file before you trust it:

ls -l output.wav      # expect tens of kilobytes, not a few hundred bytes
file output.wav       # expect: RIFF (little-endian) data, WAVE audio
head -c 4 output.wav  # expect: RIFF

Then play it:

afplay output.wav

aplay output.wav

start output.wav

Hearing speech is the success condition. If head -c 4 prints { you received JSON, so check your Accept header. If it prints readable English, you received an error message, so open the file and match it below.

If it did not work

Everything here fails before any audio is produced. For the complete list of statuses and messages, see the error reference.

What you see	Cause	Fix
File contains `invalid api key`	The key is not recognized	Recopy it from the API Tokens page. The header is `Authorization: Bearer <key>`
File contains `empty apikey`	The header was sent with an empty value	Your shell variable did not expand. Echo it and confirm it is set
File contains `Missing Authorization header`	No `Authorization` header reached the API	Check for a typo in the header name
File contains `invalid subscription`	The key is valid but the account has no active subscription	Check the account before regenerating the key. A billing problem arrives as a 401 here, not a 402
File contains `speaker is required`	`speaker` was omitted	Add `speaker`. There is no default voice
File contains `text must not be empty`	`text` was `""`	Send at least one character
File contains `text is too long`	`text` exceeded the configured limit	Split the text across requests
File starts with `{"audioContent"`	The `Accept` header was missing or unrecognized	Set `Accept` to a supported value such as `audio/wav`. See Streaming formats
File is 0 bytes	The request never completed	Confirm the URL is `https://users.rime.ai/v1/rime-tts` and reachable from your network
Audio plays but the voice is wrong	The `speaker`, `modelId`, and `lang` combination is not one the catalog serves	An unsupported combination is not reliably rejected. Verify the voice against the Coda catalog

How the request works

Build the request step by step

Create a file called rime_hello_world.py, rime_hello_world.js, or rime_hello_world.ts and import the required library modules:

import json
import urllib.request

const fs = require("fs");

import * as fs from "fs";

Set the request headers with your Rime API key and the expected audio format:

RIME_API_KEY = "your_api_key_here"

headers = {
    "Accept": "audio/wav",
    "Authorization": f"Bearer {RIME_API_KEY}",
    "Content-Type": "application/json"
}

const RIME_API_KEY = "your_api_key_here";

const headers = {
    "Accept": "audio/wav",
    "Authorization": `Bearer ${RIME_API_KEY}`,
    "Content-Type": "application/json"
};

const RIME_API_KEY: string = "your_api_key_here";

const headers: Record<string, string> = {
    "Accept": "audio/wav",
    "Authorization": `Bearer ${RIME_API_KEY}`,
    "Content-Type": "application/json"
};

Set the text, speaker, and model in the request body:

payload = {
    "text": "Hello! This is Rime speaking.",
    "speaker": "celeste",
    "modelId": "coda"
}

const payload = {
    text: "Hello! This is Rime speaking.",
    speaker: "celeste",
    modelId: "coda"
};

const payload = {
    text: "Hello! This is Rime speaking.",
    speaker: "celeste",
    modelId: "coda"
};

This payload includes the three required parameters:

text is the content to synthesize.
speaker selects a voice from the voice catalog.
modelId selects the model. Use coda for the flagship voice lineup or mistv3 for the lowest time to first audio.

The Coda API reference lists the optional request parameters.Send the POST request and write the streamed audio response to a file:

data = json.dumps(payload).encode("utf-8")

request = urllib.request.Request(
    "https://users.rime.ai/v1/rime-tts",
    data=data,
    headers=headers,
    method="POST"
)

with urllib.request.urlopen(request) as response:
    with open("output.wav", "wb") as f:
        while chunk := response.read(4096):
            f.write(chunk)

print("Audio saved to output.wav")

async function generateSpeech() {
    const response = await fetch("https://users.rime.ai/v1/rime-tts", {
        method: "POST",
        headers: headers,
        body: JSON.stringify(payload)
    });

    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    fs.writeFileSync("output.wav", Buffer.from(buffer));
    console.log("Audio saved to output.wav");
}

generateSpeech();

async function generateSpeech(): Promise<void> {
    const response = await fetch("https://users.rime.ai/v1/rime-tts", {
        method: "POST",
        headers: headers,
        body: JSON.stringify(payload)
    });

    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    fs.writeFileSync("output.wav", Buffer.from(buffer));
    console.log("Audio saved to output.wav");
}

generateSpeech();

These examples stream the response but write each chunk to disk. Interactive applications can play chunks as they arrive so speech begins before the complete response is generated. The LiveKit quickstart shows this pattern in a conversational agent.

Choose a voice

Change the speaker parameter to use another voice:

payload = {
    "text": "Hello! This is Rime speaking.",
    "speaker": "orion",  # Try different voices here
    "modelId": "coda"
}

const payload = {
    text: "Hello! This is Rime speaking.",
    speaker: "orion",  // Try different voices here
    modelId: "coda"
};

const payload = {
    text: "Hello! This is Rime speaking.",
    speaker: "orion",  // Try different voices here
    modelId: "coda"
};

Browse all available voices on the Voices page.

Custom pronunciation

Custom pronunciation is supported on Mist v1 and Mist v2 only. Coda, Arcana, and Mist v3 do not support phonemizeBetweenBrackets.

The mistv2 model lets you specify the pronunciation of brand names or uncommon words using the Rime phonetic alphabet. Add the custom pronunciation in curly brackets and set phonemizeBetweenBrackets to true:

payload = {
    "text": "Welcome to {r1Ym} labs.",
    "speaker": "peak",
    "modelId": "mistv2",
    "phonemizeBetweenBrackets": True
}

const payload = {
    text: "Welcome to {r1Ym} labs.",
    speaker: "peak",
    modelId: "mistv2",
    phonemizeBetweenBrackets: true
};

const payload = {
    text: "Welcome to {r1Ym} labs.",
    speaker: "peak",
    modelId: "mistv2",
    phonemizeBetweenBrackets: true
};

See the Rime phonetic alphabet for the full symbol reference, and Pronunciation control for an overview of all the ways to control pronunciation.

Production choices

The LiveKit quickstart extends the same streaming API into a real-time voice agent. These references cover the main model, voice, latency, and transport decisions:

Models

Compare Coda (flagship) and Mist v3 (fast)

Voices

Browse all available voice options

Latency

Optimize for real-time performance

Coda Streaming API

Stream audio with our flagship model

Overview

Quickstart

Voice agents

Voices & models

Customizing speech

Streaming & performance

Integrations

On-prem

Account & updates

TTS in five minutes

Prerequisites

Copy the request

Run it

Confirm it worked

If it did not work

Build the request step by step

Choose a voice

Custom pronunciation

Production choices

Models

Voices

Latency

Coda Streaming API

​Prerequisites

​Copy the request

​Run it

​Confirm it worked

​If it did not work

​Build the request step by step

​Choose a voice

​Custom pronunciation

​Production choices

Models

Voices

Latency

Coda Streaming API

Prerequisites

Copy the request

Run it

Confirm it worked

If it did not work

Build the request step by step

Choose a voice

Custom pronunciation

Production choices