VibeVoice API: What It Is and Its Text-Side Partner

What people mean by VibeVoice

VibeVoice is the name of an open-source speech synthesis project from Microsoft. Its focus is long-form, conversational audio with more than one speaker, the kind of thing you would want for a podcast-style episode or an audiobook with several voices. It is a speech model. It takes text in and produces audio out.

When someone types that name next to the word API, the intent usually falls into one of three buckets. Some people want a hosted endpoint that runs the speech model for them. Some want to run the open weights on their own GPU and wrap them in a small HTTP service. And some are building a whole pipeline and only need to know where the words come from before the voices start.

This site covers the third bucket and nothing else. We do not run VibeVoice, we are not affiliated with its authors, and nothing here returns audio. What we offer is a hosted, OpenAI-compatible API for one open-weight text model, run by an independent provider and tuned to answer without content refusals for lawful adult use. If you need sound, you need a speech model or a speech host as well. Check the project page and whichever provider you pick for their current terms, limits and pricing, because those are theirs to state, not ours.

Where a text model sits in a speech pipeline

Speech models are good at reading text. They are not good at deciding what the text should say. That job belongs upstream, and a typical pipeline looks like this:

1. Brief. You write a few lines: topic, tone, number of speakers, target length.
2. Script. A language model turns the brief into turn-by-turn dialogue or narration.
3. Cleanup. A second pass (code or another model call) expands numbers, removes markup and splits the script into chunks.
4. Speech. The speech model reads the cleaned script and produces audio.
5. Edit. You trim, normalise volume and publish.

Steps 1 to 3 are text work, and that is where this API fits. The reason to choose a model without content refusals is practical. If you write horror audio drama, crime fiction, a villain monologue or an adult-themed companion character, a model that stops mid-script to deliver a warning breaks your automation. Worse, the refusal sentence is just more text, so a speech model will happily read it out in a cheerful voice. A model that follows the brief removes that failure mode.

The limit is fixed and not negotiable: no sexual content involving minors, ever. Everything else is for lawful adult use, and the responsibility for what you publish stays with you.

Connect to the text side in two minutes

The API speaks the OpenAI chat format. Any OpenAI SDK or client works once you change the base URL and the key. The model ID is uncensored, and authentication is a bearer token. Two endpoints exist: POST /v1/chat/completions and GET /v1/models.

First, check that your key works with a tiny request (GET /v1/models also lists the available model):

Copycurl https://api.vibevoice.top/v1/chat/completions \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Say hello in five words."}]}'

Then send a first chat request from Python:

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.vibevoice.top/v1",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write dialogue meant to be read aloud."},
        {"role": "user", "content": "Two hosts argue for 6 lines about whether lighthouses still matter."},
    ],
    temperature=0.8,
)
print(resp.choices[0].message.content)

You can get a key from the API key page. New users can claim $0.50 of trial credit with one click there after sign-up, valid for 7 days and without a card. The quickstart has the same calls for Node and curl.

Generate a multi-speaker script as structured data

Free-form text is awkward to feed into a speech tool. Asking for JSON gives you turns you can validate, reorder and format however your speech model expects. JSON mode is supported through response_format, and it helps to say the word JSON in the prompt as well as in the parameter.

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.vibevoice.top/v1", api_key="YOUR_KEY")

system = (
    "You write two-person podcast dialogue. Return JSON only: "
    '{"turns": [{"speaker": 1 or 2, "text": "..."}]}. '
    "Each text is one to three spoken sentences. No stage directions."
)

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    temperature=0.8,
    messages=[
        {"role": "system", "content": system},
        {"role": "user", "content": "Topic: why old radio dramas still hold up. Twelve turns."},
    ],
)

turns = json.loads(resp.choices[0].message.content)["turns"]
script = "\n".join("Speaker %d: %s" % (t["speaker"], t["text"]) for t in turns)
print(script)

The last two lines convert the turns into plain "Speaker 1: ..." lines. That label style is common in multi-speaker speech tools, but the exact format differs between them, so read the documentation of the one you use and adjust the final formatting line. Keeping the structured data separate from the final string means you change one line, not your prompt.

If the JSON ever fails to parse, catch the exception and retry once. Failed or refused requests are not charged, so a retry costs you nothing extra beyond the tokens of the new, successful attempt.

Write for the ear, not the eye

Text that reads well on a page often sounds stiff when spoken. Put the fixes in the system prompt so every script comes out ready for a speech model:

• Short sentences, with the occasional long one for rhythm.
• Numbers, dates and units written as words ("twenty twenty-six", "three kilometres").
• No bullet points, asterisks, hashtags, emoji or markdown. A speech model may read symbols aloud or stumble on them.
• Contractions and light interjections for casual speakers, none for a formal narrator.
• Names and unusual words spelled the way you want them pronounced, with a short glossary in the prompt if needed.

Speaker identity matters too. Give each voice a one-line profile in the prompt ("Speaker 1 is dry and sceptical, Speaker 2 is excitable and interrupts") and the dialogue gains contrast with no extra work. Temperature between 0.7 and 0.9 gives varied phrasing; lower it when you want a steady, predictable narrator. Sampling parameters such as temperature, top_p, stop, seed and the penalties are passed through to the model, so you can tune them the way you would elsewhere.

Read the first output aloud yourself before you automate anything. Thirty seconds of reading shows you which rules the prompt is missing faster than any amount of tweaking in the dark.

Length, context and what it costs

The context window is 100,000 tokens, prompt plus completion. For scripts that is generous: an outline, a character sheet and the previous chapters can all sit in the prompt together. The completion can use whatever remains of the window, and max_tokens is optional, so you do not have to guess an output cap before you start.

Billing is pay as you go from prepaid credit: $0.15 per 1M input tokens and $0.50 per 1M output tokens. Take a 20-minute two-host episode. Speaking pace is somewhere around 150 words a minute, so 3,000 words, which is roughly 4,000 tokens of output. Add a 1,000-token prompt with the brief and character notes:

• Input: 1,000 tokens x $0.15 / 1,000,000 = $0.00015
• Output: 4,000 tokens x $0.50 / 1,000,000 = $0.002
• Total: $0.00215 for the whole script

That is a fifth of a cent. The $0.50 trial credit covers more than 200 scripts of this size. Words-to-tokens ratios are rough, so check the usage block in the response for the real numbers. See the pricing page for top-ups, which run from $20 to $500 with a bonus of 5% from $50, 10% from $100 and 15% from $200. Credit does not expire.

If your pipeline also produces music or lyrics, there is a separate walkthrough in the Suno guide that uses the same API for song text.

Limits to plan around

Be clear about what the text side cannot do. It does not generate audio, images or video, it has no embeddings endpoint and it does not fine-tune. It is one model, not a router across vendors, and it is not the official API of any speech or language-model company.

On the operational side, a full key allows 8 concurrent requests and 300 requests per minute; a trial key allows 2 concurrent and 60 per minute. Go over and you get HTTP 429 with the error code rate_limited or concurrency. A streamed request holds its concurrency slot until the stream ends, which matters if you stream scripts to a preview window while other jobs run. Temporary overload also returns 429 with a Retry-After: 5 header, so a retry loop that waits five seconds is the right default. Every response carries X-Request-Id and X-Balance-USD, handy for logging and for stopping a batch before the balance runs dry.

Prompts are not used for training. The request body can be up to 8 MB, which is far more than any script needs.

More guides

• AI Voice Script Generator API: Build One With an LLM
• API Pricing Examples: Token Math for a Text LLM
• VibeVoice API: Uncensored LLM Integration for Suno