Speech Customization

Murf’s AI models not only generate natural-sounding speech quickly but also give you powerful customization controls to shape the output with precision and personality. Through intuitive controls, you can fine-tune every detail to bring your creative vision to life.

Model and feature support

Voices

Murf offers a diverse collection of 150+ AI voices across different accents, genders, and speaking styles—designed to suit a wide range of use cases from narration and marketing to training and conversation. voiceId is required on both models: send it in Stream Speech or WebSocket voice_config for Falcon 2.1, and in Synthesize Speech for Gen 2. Pick the ID from that model’s list: Falcon 2.1 or Gen 2. Each voice comes with its own unique tonal profile and supports different features such as styles and locales.

from murf import Murf, MurfRegion
client = Murf(region=MurfRegion.GLOBAL)
audio_stream = client.text_to_speech.stream(
    text="What color is the sky?",
    voice_id="Matthew",
    model="falcon-2.1",
)
with open("voice.wav", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

Multilingual

Multilingual voices enable text-to-speech synthesis that sounds authentically native across multiple languages. This allows you to use the same voice which can speak multiple languages while preserving natural pronunciation patterns specific to each language, effectively eliminating the “foreign accent” effect common in conventional Multilingual TTS systems.

Use the locale key to select which locale to use for your audio generation. Send it in Stream Speech or WebSocket voice_config for Falcon 2.1, and in Synthesize Speech for Gen 2. Use a locale listed for your voice on Falcon 2.1 or Gen 2.

from murf import Murf, MurfRegion
client = Murf(region=MurfRegion.GLOBAL)
audio_stream = client.text_to_speech.stream(
    text="Croissant",
    voice_id="Matthew",
    model="falcon-2.1",
    locale="fr-FR",
)
with open("croissant.wav", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

Styles

Murf Styles enable developers to fine-tune voice output for different contexts. Each voice supports multiple predefined styles that modify tone, emotional inflection, and delivery patterns. By passing the style parameter, you can programmatically transform a neutral voice to match specific contexts such as promotional, newscast, conversational, or inspirational to meet your application’s delivery requirements.

Here are some examples of different styles available in the Murf API:

Use the style key to select which style to use for your audio generation. Send it in Synthesize Speech. Use a style listed for your voice on the Gen 2 page.

from murf import Murf
client = Murf()
res = client.text_to_speech.generate(
    text="Oh! I will have to do this all over again.",
    voice_id="Ken",
    model_version="GEN2",
    style="Angry"
)

You can explore all supported styles and hear audio samples in our Voice Library.

Pronunciations

While our models are capable at handling complex pronunciations of heteronyms, acronyms, numbers, and proper nouns, you might sometimes need a specific pronunciation for certain words. Our custom pronunciation feature lets you adjust how words are spoken to perfectly match your context or accent preferences.

Here are a few examples of words and how they sound before and after adding custom pronunciations:

There are two ways to set a custom pronunciation. On Falcon 2.1, you can write the word in IPA right in your text. On both Falcon 2.1 and Gen2, you can pass a pronunciationDictionary with the request.

Method 1: IPA in your text (Falcon 2.1)

Write the word in the International Phonetic Alphabet (IPA) between forward slashes, wrapped in double quotes, in place of the word itself. Falcon 2.1 says the word exactly as written. This works in Stream Speech and in WebSocket text frames, and suits text an LLM writes on the fly.

• Use both the quotes and the slashes: "/mɜːrf/".
• Replace the word with its IPA. Don’t write both, or the word is spoken twice.
• Keep punctuation outside the quotes: "/mɜːrf/". not "/mɜːrf/."
• In a raw JSON body, escape the quotes: \"/mɜːrf/\". The SDKs, json.dumps and JSON.stringify do this for you.

HTTP streaming accepts IPA inside text. Send the same text in a WebSocket text frame.

from murf import Murf, MurfRegion
client = Murf(region=MurfRegion.GLOBAL)
audio_stream = client.text_to_speech.stream(
    text='Hi "/ʃɪˈvɔːn/", thanks for calling "/mɜːrf/". How can I help you today?',
    voice_id="Matthew",
    model="falcon-2.1",
    format="MP3",
)
with open("ipa.mp3", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

Method 2: Pronunciation dictionary (Falcon 2.1 and Gen 2)

Pass pronunciationDictionary in the request body of Stream Speech (Falcon 2.1) or Synthesize Speech (Gen2). On WebSockets, send the same map as pronunciation_dictionary inside voice_config. Each key is a word as it appears in your text. Its value says how to say it:

• "type": "IPA" with the IPA in pronunciation, written without quotes or slashes, for example "mɜːrf".
• "type": "SAY_AS" with the words to say instead, for example "two thousand and ten" for 2010.

Each entry applies every time the word appears in the request, so you can keep your text unchanged and send the same dictionary with every call. Use it for brand and product names, and for numbers or acronyms you want read a set way. On WebSockets, set it once per context; it applies to all text in that context.

from murf import Murf, MurfRegion
client = Murf(region=MurfRegion.GLOBAL)
audio_stream = client.text_to_speech.stream(
    text="Thanks for calling Murf. Your TTS credits renew on the first of every month, and you can track them in your Murf dashboard.",
    voice_id="Matthew",
    model="falcon-2.1",
    format="MP3",
    pronunciation_dictionary={
        "Murf": {"type": "IPA", "pronunciation": "mɜːrf"},
        "TTS": {"type": "SAY_AS", "pronunciation": "text to speech"},
    },
)
with open("dictionary.mp3", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

Pauses

Our models are capable of adding natural pauses based on the text and context. In some cases, you may want to adjust the pause duration between two words to achieve the desired effect in your speech.

In the Synthesize Speech operation, the text key of the request body holds the text to be synthesized. This text key can be tweaked to add a pause between words in your script. This is done using Murf’s pause syntax: [pause <duration>].

Specify how long you want the pause to be in seconds by replacing the <duration> part of the syntax, and you’ll get silence for that duration in the generated voiceover. The pause duration can be between 0.1s to 5s.

from murf import Murf
client = Murf()
res = client.text_to_speech.generate(
    text="The answer to the problem was [pause 1s] patience.",
    voice_id="Terrell",
    model_version="GEN2"
)

Audio Duration

The audioDuration key in Synthesize Speech operation’s request body lets you specify the desired length of the generated audio (in seconds), and the system adjusts the speech to fit this duration.

Here is an example of how audio duration helps in generating voiceovers of specific lengths:

This can be useful for matching voiceovers with specific audio lengths or other time constraints. The system will try to match the duration of the generated audio to audioDuration as closely as possible.

If there’s a significant difference between the requested and actual duration, consider changing the text length or audioDuration value for better alignment.

• Valid values: A double value representing the time in seconds.
• Guideline: As a rule of thumb. ~150 words/1000 characters of text generates around 60 seconds of audio.

from murf import Murf
client = Murf()
res = client.text_to_speech.generate(
    text="The team is down by three points. Ten seconds left on the clock! The next play could decide the game",
    voice_id="Miles",
    model_version="GEN2",
    audio_duration=8.0
)

Speed

The rate key controls the speed at which the voice speaks. Adjusting this parameter lets you make the voice output faster or slower. The range is the same on both models: send rate in Stream Speech or WebSocket voice_config for Falcon 2.1, and in Synthesize Speech for Gen 2.

Higher values mean higher speed, and lower values slow down the speech.

• Valid values: Any integer between -50 and 50
• Default value: 0

from murf import Murf, MurfRegion
client = Murf(region=MurfRegion.GLOBAL)
audio_stream = client.text_to_speech.stream(
    text="I cannot believe it! Is that really you, captain?",
    voice_id="Matthew",
    model="falcon-2.1",
    rate=10,
)
with open("speed.wav", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

Pitch

The pitch key controls the tone or frequency of the generated voice. Increasing the pitch makes the voice sound higher (more treble), while decreasing it results in a deeper (more bass) voice. The range is the same on both models: send pitch in Stream Speech or WebSocket voice_config for Falcon 2.1, and in Synthesize Speech for Gen 2.

• Valid values: Any integer between -50 and 50
• Default value: 0

from murf import Murf, MurfRegion
client = Murf(region=MurfRegion.GLOBAL)
audio_stream = client.text_to_speech.stream(
    text="I cannot believe it! Is that really you, captain?",
    voice_id="Matthew",
    model="falcon-2.1",
    pitch=-10,
)
with open("pitch.wav", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

Volume offset

The volumeOffset key adjusts the loudness of generated speech relative to Falcon 2.1’s default output. Falcon 2.1 produces audio at a consistent, broadcast-ready level. Voice agents are rarely heard in broadcast conditions—callers hear them through phone earpieces, compressed telephone lines, and noisy rooms. Use volumeOffset to match the agent’s voice to where it will be heard.

Positive values make the voice louder; negative values make it quieter. At 0 (the default), audio is left exactly as generated. The scale is relative, not an absolute loudness target: a given value raises or lowers the voice by the same proportion for every voice and every utterance. Send it in Stream Speech or WebSocket voice_config.

• Type: Integer
• Valid values: -50 to 50. Values outside this range are clamped.

Built for real-time conversation

• No added latency. The adjustment runs as audio streams, so time to first byte is unchanged. Extra processing takes a few milliseconds per chunk—far below what a caller can perceive.
• Clean at every setting. Negative values reduce level only. Positive values include built-in peak protection, so the voice stays free of harsh distortion even at the top of the range. Because the loudest syllables are held in check, each step adds a little less near the maximum than lower in the range.
• Consistent across turns. The same setting produces the same loudness on every utterance, so the agent does not sound closer or farther away from one turn to the next.

Choosing a value

Start from where the agent is heard.

Phone lines. Loudness often helps intelligibility more than equalization. Narrowband codecs discard high frequencies that carry consonant detail, so a modest lift in level is an effective way to keep the agent understandable. Many Android devices also play voice-call audio well below media volume. If callers on mobile say the agent sounds faint, raise volumeOffset before changing anything else.

Negative values. Use a negative volumeOffset when the agent sounds louder than audio around it—pre-recorded IVR prompts, music beds in your app, or a human agent the call is handed to. Consistent levels make the experience feel like one seamless system.

Best practices

1. Set it once per session. On WebSockets, pass volumeOffset in the session’s voice_config and leave it fixed for the conversation. Change it between turns only if your application deliberately responds to the caller’s environment.
2. Mind your echo canceller. On speakerphone or far-field devices, a louder agent feeds more of its own voice back into the microphone. If you see false barge-ins or the agent interrupting itself, lower volumeOffset before adjusting voice activity detection (VAD) thresholds.
3. Test on the actual channel. Judge the setting on a phone call or target device, not on studio headphones. A level that sounds excessive at your desk is often right on a handset.
4. Evaluate each voice independently. Every voice has its own baseline loudness. A voice that sounds too quiet at a given offset may need a different value than one that sounds right at the same setting.
5. Watch for quality changes at higher volumes. Volume offset amplifies the model output, so you may hear small imperfections as the offset increases. If you notice artifacts, lower the offset.

HTTP streaming accepts volumeOffset in the request body. Send the same setting in a WebSocket voice_config frame.

from murf import Murf, MurfRegion
client = Murf(region=MurfRegion.GLOBAL)
audio_stream = client.text_to_speech.stream(
    text="Thanks for calling. How can I help you today?",
    voice_id="Matthew",
    model="falcon-2.1",
    format="ULAW",
    sample_rate=8000,
    volume_offset=25,
)
with open("volume.ulaw", "wb") as f:
    for chunk in audio_stream:
        f.write(chunk)

Both examples use 25, at the top of the 10–25 range suggested for phone calls.

Limits

Values outside -50 to 50 aren’t rejected. They’re clamped to the nearest limit, so 80 is applied as 50 and -70 as -50.

Variations

Variations allows you to generate voiceover using three primary parameters: pause, pitch, and speed. A higher variation value results in a more dynamic voice output, incorporating changes in speech delivery, pitch shifts, and pauses to make the audio sound more natural and less robotic.

Variation 1

Variation 5

Increasing the value will add more variation in voice style, with noticeable shifts in pause, pitch, and speed

• Valid values: An integer between 0 and 5
• Default value: 1

from murf import Murf
client = Murf()
res = client.text_to_speech.generate(
    text="And off they went, walking gently into the sunset without a single care in the world.",
    voice_id="Julia",
    model_version="GEN2",
    variation=5
)