TTS in five minutes

By the end of this page, you’ll have a WAV file of a Rime voice reading a short sentence, made with one 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. No Rime package is required.Rime publishes Python rime-api and JavaScript @rimelabs/api with generated TTS message definitions for the standalone engine. See package installation and scope.Framework-specific starters are available for Next.js, Vite, Express, plain Node, and FastAPI.

The scripts read your key from the RIME_API_KEY environment variable, which keeps it out of files you might share or commit. Set it in the terminal you’ll run them from:

export RIME_API_KEY="your_api_key_here"

$env:RIME_API_KEY = "your_api_key_here"

Copy the request

Each script sends “Hello! This is Rime speaking.” to the celeste voice and saves the audio to output.wav, so you can replay it as many times as you need while you check it. One sentence is short enough to hear the whole result. 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 $RIME_API_KEY" \
  --header 'Content-Type: application/json' \
  --header 'Accept: audio/wav' \
  --fail \
  --show-error \
  --output output.wav \
  --data '{
    "text": "Hello! This is Rime speaking.",
    "speaker": "celeste",
    "modelId": "coda"
  }'

import json
import os
import urllib.request

RIME_API_KEY = os.environ["RIME_API_KEY"]

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 { Readable } = require("stream");
const { pipeline } = require("stream/promises");

const RIME_API_KEY = process.env.RIME_API_KEY;
if (!RIME_API_KEY) {
    throw new Error("Set RIME_API_KEY before running this script.");
}

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}`);
    }

    if (!response.body) {
        throw new Error("The response did not include an audio body.");
    }

    await pipeline(
        Readable.fromWeb(response.body),
        fs.createWriteStream("output.wav")
    );
    console.log("Audio saved to output.wav");
}

generateSpeech();

import * as fs from "fs";
import { Readable } from "stream";
import { pipeline } from "stream/promises";

const RIME_API_KEY = process.env.RIME_API_KEY;
if (!RIME_API_KEY) {
    throw new Error("Set RIME_API_KEY before running this script.");
}

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}`);
    }

    if (!response.body) {
        throw new Error("The response did not include an audio body.");
    }

    await pipeline(
        Readable.fromWeb(response.body),
        fs.createWriteStream("output.wav")
    );
    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

Play the file. If you hear the sentence, your key, the request, and the voice all worked.

afplay output.wav

aplay output.wav

start output.wav

A file on disk isn’t proof of audio. If the player won’t open it, check what the file contains:

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

A file without the RIFF header usually means the request reached the API with no Accept header or a wildcard such as */*, for example because a proxy or client wrapper dropped the header. For Coda, the API then streams raw 16-bit PCM (audio/pcm) with no WAV header, and players won’t open it. The cURL example uses --fail --show-error so HTTP errors stop the command instead of being saved as output.wav.

If it did not work

Find the row that matches what you see. For the complete list of statuses and messages, see the error reference.

What you see	Cause	Fix
The client reports HTTP 401	The API key is missing or invalid, or the account has no active subscription	Confirm `RIME_API_KEY` is set, recopy it from the API Tokens page, and check the account
The client reports HTTP 400	A required field is missing or invalid	Check `speaker`, `text`, `modelId`, and `lang` against the error reference
The client reports that the text is too long	`text` exceeded the configured limit	Split the text across requests
The client reports HTTP 406	`Accept` names a format the API can’t stream	Set `Accept` to a supported value such as `audio/wav`. The response body lists the supported types
File won’t play and doesn’t start with `RIFF`	The request arrived with no `Accept` header or a wildcard `Accept`, so the API returned raw PCM	Set `Accept` to `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 os
import urllib.request

const fs = require("fs");
const { Readable } = require("stream");
const { pipeline } = require("stream/promises");

import * as fs from "fs";
import { Readable } from "stream";
import { pipeline } from "stream/promises";

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

RIME_API_KEY = os.environ["RIME_API_KEY"]

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

const RIME_API_KEY = process.env.RIME_API_KEY;
if (!RIME_API_KEY) {
    throw new Error("Set RIME_API_KEY before running this script.");
}

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

const RIME_API_KEY = process.env.RIME_API_KEY;
if (!RIME_API_KEY) {
    throw new Error("Set RIME_API_KEY before running this script.");
}

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 full Coda 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}`);
    }

    if (!response.body) {
        throw new Error("The response did not include an audio body.");
    }

    await pipeline(
        Readable.fromWeb(response.body),
        fs.createWriteStream("output.wav")
    );
    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}`);
    }

    if (!response.body) {
        throw new Error("The response did not include an audio body.");
    }

    await pipeline(
        Readable.fromWeb(response.body),
        fs.createWriteStream("output.wav")
    );
    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

Keep the same sentence and change only speaker. With the words held constant, it’s easier to hear what the new voice changes:

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"
};

The Voices page lists starter voices and the full catalog. Each voice speaks one language. If you choose a voice in another language, give it text in that language and add lang with the voice’s language tag.

Custom pronunciation

Custom pronunciation is supported on Mist v1, Mist v2, and English Mist v3. Coda and non-English 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 Coda, Rime’s 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