August 28, 2026AIExplore

How to Control Pronunciation and Pacing in ElevenLabs

Mark hard names with IPA or phoneme tools, pace lines with pauses and punctuation, and match controls to eleven_v3 or v2 model capabilities.

ElevenLabs

Pronunciation and pacing control keep names, acronyms, numbers, and pauses intelligible. Official best practices support SSML phoneme tags on v2 models, IPA wrapped in forward slashes on eleven_v3, and audio tags for delivery on v3. eleven_v3 does not support SSML break tags. Use punctuation and tags such as [pause] instead. Pronunciation dictionaries help recurring terms in Studio and Dubbing workflows. Overview: /explore/elevenlabs.

This guide shows practical marking patterns and model aware choices. Pair with narration at /blog/how-to-use-elevenlabs-for-text-to-speech-narration and API chunking at /blog/how-to-use-the-elevenlabs-api-for-voice-applications.

Pick the control surface for your model

If you need IPA slash notation and audio tags, choose eleven_v3. If you need SSML phoneme or break tags, choose a documented v2 path. Do not mix unsupported tags.

Step by step pronunciation workflow

1. List hard tokens

Collect brand names, people, places, chemicals, and acronyms. Decide spoken expansions.

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Token list Acme -> ACK mee UN -> United Nations glucose -> IPA on v3 SKU -> S K U. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Token list Acme -> ACK mee UN -> United Nations glucose -> IPA on v3 SKU -> S K U" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure elevenlabs specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Token list Acme -> ACK mee UN -> United Nations glucose -> IPA on v3 SKU -> S K U" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

2. Mark the script for the model

On v3 wrap IPA in slashes and insert audio tags. On supported v2 use phoneme tags or dictionaries.

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: v3 example Welcome to /ˈækmi/ Robotics. [pause] Today we cover onboarding.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "v3 example Welcome to /ˈækmi/ Robotics. [pause] Today we cover onboarding." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "v3 example Welcome to /ˈækmi/ Robotics. [pause] Today we cover onboarding." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

3. Control pacing without over tagging

Prefer sentence breaks and occasional [pause] tags. Too many breaks can destabilize generations on supported models.

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Pacing pass Short sentences. One pause before the ask. No stack of five break tags.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Pacing pass Short sentences. One pause before the ask. No stack of five break tags." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Pacing pass Short sentences. One pause before the ask. No stack of five break tags." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Practical pronunciation and pacing examples

Brand IPA

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Welcome to /ˈækmi/ Robotics.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Welcome to /ˈækmi/ Robotics." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Welcome to /ˈækmi/ Robotics." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Medical IPA

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: The patient takes /ɡluːˈkoʊs/ daily.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "The patient takes /ɡluːˈkoʊs/ daily." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "The patient takes /ɡluːˈkoʊs/ daily." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

City IPA

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: We meet in /ˌsænfrənˈsɪskoʊ/ next week.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "We meet in /ˌsænfrənˈsɪskoʊ/ next week." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "We meet in /ˌsænfrənˈsɪskoʊ/ next week." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Pause before CTA

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Review the checklist. [pause] Then tap continue.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Review the checklist. [pause] Then tap continue." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Review the checklist. [pause] Then tap continue." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Whisper aside

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: [whispers] Do not share this code outside the team.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "[whispers] Do not share this code outside the team." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "[whispers] Do not share this code outside the team." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Excited beat

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: [excited] We cleared the queue!. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "[excited] We cleared the queue!" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "[excited] We cleared the queue!" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Alias expansion note

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Dictionary alias: UN -> United Nations on Multilingual v2 workflows.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Dictionary alias: UN -> United Nations on Multilingual v2 workflows." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Dictionary alias: UN -> United Nations on Multilingual v2 workflows." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Numbers spoken

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Ship by seventeen hundred hours. Say times the way listeners should hear them.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Ship by seventeen hundred hours. Say times the way listeners should hear them." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Ship by seventeen hundred hours. Say times the way listeners should hear them." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

SKU spelling

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Enter code S K U 9 4 2.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Enter code S K U 9 4 2." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Enter code S K U 9 4 2." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Stability note v3

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: If delivery swings wildly, move Stability toward Natural per v3 guidance.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "If delivery swings wildly, move Stability toward Natural per v3 guidance." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "If delivery swings wildly, move Stability toward Natural per v3 guidance." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

More marked scripts

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Script: Call Doctor /ˈliː/ at extension 4 1 2.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Script: Call Doctor /ˈliː/ at extension 4 1 2." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Script: Call Doctor /ˈliː/ at extension 4 1 2." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Script: Pronounce GIF with hard G in this course.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Script: Pronounce GIF with hard G in this course." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Script: Pronounce GIF with hard G in this course." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Script: Wait. [pause] Confirm the address once more.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Script: Wait. [pause] Confirm the address once more." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Script: Wait. [pause] Confirm the address once more." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Script: [sarcastic] Sure. That will scale forever.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Script: [sarcastic] Sure. That will scale forever." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Script: [sarcastic] Sure. That will scale forever." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Scenario:
A realistic elevenlabs workflow is being prepared for Use ElevenLabs for Text to Speech Narration using elevenlabs. The starting requirement is: Script: Split long legal text into clauses with periods, not one endless sentence.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Script: Split long legal text into clauses with periods, not one endless sentence." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Script: Split long legal text into clauses with periods, not one endless sentence." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Tips

Build a token glossary first
Match tags to model capabilities
Prefer light pause usage
Use dictionaries for recurring terms
Tune Stability on v3 thoughtfully
Listen specifically for stress errors

Keep a short generation log: voice id or name, model id, Stability, Similarity, and the one change you will try next. That habit turns two regenerations into learning instead of noise.

When credits, plan features, or model access differ from memory, open elevenlabs.io/pricing and the official models page. Limits change, so do not promise client deliverables from outdated screenshots.

Treat the first take as a draft. Listen for clipped words, wrong stress on names, and accidental stage direction read aloud before you rewrite the whole script.

If you collaborate, store winning scripts and voice settings on a shared page. Reuse the skeleton and change only the line that failed.

For product work, decide latency versus expressiveness before you pick a model. Flash favors speed. Multilingual v2 favors long form stability. v3 favors performance tags.

Separate exploration from release. Explore voices freely, then re check commercial usage rules on a paid plan before monetizing outputs.

Close each session by naming keeper takes and discarding near misses. A clean library saves time when a producer asks for the calm narrator from Tuesday.

Prefer clear punctuation and short sentences over vague vibe words alone. The model reads what you write.