Every text-to-speech engine mispronounces something. Abbreviations like "SCSI" come out letter-by-letter instead of "scuzzy." Foreign surnames get flattened. Medical terms like "dyspnea" trip up even high-end models. The root cause is always the same: the engine's grapheme-to-phoneme (G2P) layer guessed wrong.
This guide covers five concrete methods to override G2P defaults, compares provider support across Google Cloud TTS, Amazon Polly, Azure Speech, ElevenLabs, and Orca, and walks through fixes for the most common pronunciation failures.
What Is Grapheme-to-Phoneme (G2P) Conversion?
Grapheme-to-phoneme (G2P) conversion maps written characters (graphemes) to speech sounds (phonemes). Modern TTS engines use neural G2P models trained on pronunciation dictionaries. The CMU Pronouncing Dictionary, for example, contains 106,837 training words with ARPAbet transcriptions for North American English. Transformer-based G2P models achieve the highest accuracy on known words but still fail on inputs outside their training distribution.
Three categories of words consistently break G2P:
Abbreviations and acronyms: "NATO" should be spoken as a word; "FBI" should be spelled out. G2P has no reliable way to distinguish the two without context.
Proper names: The surname "Ng" is a single syllable (roughly "eng"). Place names like "Worcestershire" follow historical pronunciation, not spelling.
Domain-specific terms: Medical, legal, and technical vocabularies contain thousands of words absent from general dictionaries. "Apheresis," "estoppel," and "kubectl" are everyday terms in their fields but uncommon in G2P training sets.
Five Methods to Fix TTS Pronunciation
1. SSML Phoneme Tags
The SSML syntax guide defines the <phoneme> element, which lets developers specify exact pronunciation using a phonetic alphabet. This is the most precise override available. The engine bypasses G2P entirely for the tagged word and uses the supplied phonemes.
Example in IPA (International Phonetic Alphabet):
Google Cloud TTS accepts IPA in <phoneme> tags and supports <sub> for simple replacements, but offers no custom lexicon API. Amazon Polly supports both IPA and X-SAMPA in phoneme tags, plus custom lexicons via the W3C Pronunciation Lexicon Specification (PLS), with up to five lexicons per synthesis request. Azure Speech accepts IPA and SAPI phoneme alphabets alongside custom lexicon uploads.
ElevenLabs supports <phoneme> with IPA and CMU ARPAbet on Flash v2, Turbo v2, and English v1 models. As of June 2026, V3 models have opt-in phoneme support. Phoneme tags are currently English-only on ElevenLabs.
2. Substitution Aliases
The SSML <sub> element replaces one string with another before G2P runs. It does not specify phonemes directly; instead, it substitutes a word the engine already pronounces correctly.
This works well for abbreviations that should expand ("WHO" to "World Health Organization") and for numbers or symbols that need specific readings ("St." to "Street" vs. "Saint").
3. Custom Lexicons (PLS)
The W3C Pronunciation Lexicon Specification defines an XML format for mapping words to pronunciations. A lexicon file can contain hundreds of entries and applies to every synthesis call that references it.
Amazon Polly allows up to five PLS lexicons per request. Azure Speech supports custom lexicon uploads as well. Google Cloud TTS does not support PLS lexicons. ElevenLabs does not support lexicons.
4. Text Preprocessing Rules
Before sending text to the TTS engine, a preprocessing layer can apply regex-based or dictionary-based transformations. This is provider-agnostic and works with any engine, including those with limited SSML support. Common preprocessing tasks:
- Expanding abbreviations: "Dr." to "Doctor," "vs." to "versus."
- Normalizing numbers: "$3.5M" to "three point five million dollars."
- Handling mixed-case acronyms: applying letter-by-letter reading for all-caps tokens under a certain length.
The downside is that preprocessing rules accumulate technical debt. A large rule set becomes hard to maintain and can introduce unexpected interactions. Rules also run before SSML parsing, so they must produce valid SSML if the output contains tags.
5. Inline Phoneme Notation
Orca takes a different approach. Instead of wrapping words in XML tags, Orca uses a lightweight inline syntax:
The word goes before the pipe, ARPAbet phonemes after it. No XML parsing, no separate lexicon file. This makes inline notation a natural fit for streaming TTS pipelines where SSML overhead adds latency. Orca also supports IPA subsets for non-English languages, extending pronunciation control beyond English.
Pronunciation Override Support by TTS Providers
| Provider | Phoneme Tags | Alphabets | <sub> | Custom Lexicon | Inline Notation |
|---|---|---|---|---|---|
| Google Cloud TTS | Yes | IPA | Yes | No | No |
| Amazon Polly | Yes | IPA, X-SAMPA | Yes | Yes (PLS, up to 5) | No |
| Azure Speech | Yes | IPA, SAPI | Yes | Yes (PLS) | No |
| ElevenLabs | Yes (select models) | IPA, CMU ARPAbet | No | No | No |
| Orca | No (uses inline) | ARPAbet, IPA subsets | No | No | Yes ({word|phonemes}) |
Common TTS Pronunciation Problems to Fix
Abbreviations That Should Be Spelled Out
Acronyms like "API," "SQL," and "CEO" need letter-by-letter reading. Two reliable approaches:
SSML <say-as>: Most providers support <say-as interpret-as="characters">SQL</say-as>, which forces letter-by-letter reading.
Preprocessing: Insert periods or spaces between letters ("S.Q.L." or "S Q L") before sending to the engine. Less elegant, but works everywhere.
Abbreviations That Should Be Spoken as Words
"NASA," "SCSI," and "GIF" should be spoken as words, not spelled out. If the engine spells them, use <sub> to replace them with a phonetic respelling ("scuzzy" for SCSI) or use <phoneme> for exact control.
Foreign and Unusual Names
Names are the hardest category. "Ng" is roughly "eng" in common American usage. "Siobhan" is "shih-VAWN." No G2P model covers every name. The fix is almost always a phoneme tag with IPA or ARPAbet, stored in a custom lexicon if the application handles many names.
Medical, Legal, and Technical Terms
Domain vocabularies contain thousands of words that general G2P models have never seen. "Dyspnea" (disp-NEE-uh), "amicus" (uh-MEE-kus), and "kubectl" (cube-control) are everyday terms in their fields. Build a domain-specific lexicon or preprocessing dictionary before deployment. A healthcare TTS application might start with 500+ medical term overrides; that list will grow.
Heteronyms
Heteronyms are words spelled the same but pronounced differently depending on meaning. "Read" (present) vs. "read" (past). "Lead" (the verb) vs. "lead" (the metal). "Bass" (the fish) vs. "bass" (the instrument). Context-aware G2P models handle common heteronyms, although it's harder for streaming text-to-speech engines, as they cannot predict the upcoming words: I read a book every day vs. I read a book yesterday.
Get Started
Orca Streaming Text-to-Speech provides inline pronunciation control with zero XML overhead, supports ARPAbet for English and IPA subsets for non-English languages, and runs on-device for privacy-sensitive deployments. Explore the Orca documentation to learn more about Orca's custom pronunciation.
Start BuildingFAQ
IPA (International Phonetic Alphabet) is the most widely supported and covers all languages. ARPAbet is simpler for English-only applications. The choice depends on provider support and whether the application needs multilingual pronunciation.
It depends on the vendor. Amazon Polly allows up to five PLS lexicons per synthesis request. Azure Speech supports custom lexicon uploads with no published entry limit. Google Cloud TTS does not support custom lexicons. For large vocabularies (1,000+ terms), preprocessing or inline notation may be more practical than lexicon files.
SSML parsing adds some overhead. For latency-sensitive applications, inline notation (as used by Orca) avoids XML parsing entirely. Preprocessing rules also add minimal latency since they run as simple string operations before synthesis.
Some research models support fine-tuning on custom pronunciation dictionaries. However, most commercial TTS APIs do not expose G2P fine-tuning. The practical alternatives are custom lexicons, phoneme tags, and preprocessing rules.
IPA uses Unicode symbols to represent sounds across all human languages. ARPAbet uses ASCII character sequences to represent American English phonemes. ARPAbet is easier to type and read for English-only work. IPA is necessary for multilingual applications. The CMU Pronouncing Dictionary uses ARPAbet for its 106,837 entries.
