Fix Mistranscribed Names in Your Transcript (2026 Guide)

Names, brands, and place names break in AI transcripts for a single reason: the model has not seen them and substitutes the closest word it knows. Your colleague Sam becomes "Sahm." Your CEO Aoife becomes "Eva." Your product Convo becomes "Convoy." The fix runs in two stages: a find-and-replace pass on an existing transcript, and a custom vocabulary setup that stops the same errors from appearing again.

Why Proper Nouns Break Differently Than Other Words

AI transcription models learn the distribution of words that appear in their training data. Common words and common names are well-represented. Uncommon names, non-English given names, technical product names, and invented brand names are underrepresented or absent entirely.

When the model hears an unfamiliar name, it picks the closest familiar sound. "Aoife" (an Irish name pronounced EE-fa) becomes "Eva." "Sahm" becomes "Sam." "Convo" becomes "Convoy." This is a property of how language models work: the output is always a word the model has learned, never an unseen token.

Two things make this different from ordinary transcription errors:

• The substitution is consistent. The model makes the same mistake every time it hears that sound, so a long recording produces the same wrong spelling dozens of times.
• The error is out-of-vocabulary (OOV). The model cannot improve on the substitution through context alone because it has no representation of the correct word at all.

Both of those properties shape how you fix it.

The Quick Fix: Find and Replace

For a transcript you have already received, find-and-replace solves the problem in under five minutes. Build a list as you read the first few hundred words:

Sahm → Sam
Eva → Aoife
Convoy → Convo

Run each substitution. A few practical warnings:

• Use case-sensitive matching for short names that appear inside common words. Replacing "sam" without case sensitivity will break "same," "sample," and "Samsung."
• Check for variant renderings before you close the file. The model may have spelled the same name two different ways in two different paragraphs (see the "inconsistent rendering" case below).

For recurring sessions with the same people, maintain a substitution script you apply to every new transcript:

substitutions = {
    "Sahm": "Sam",
    "Eva": "Aoife",
    "Convoy": "Convo",
}

def fix_names(transcript: str) -> str:
    for wrong, right in substitutions.items():
        transcript = transcript.replace(wrong, right)
    return transcript

This turns a per-transcript chore into a one-time setup cost. The script runs in seconds on files of any length.

If you just need a clean transcript to run this pass on without setting up an account first, ConvertAudioToText starts transcribing immediately, no login required, and exports to plain text or DOCX so your substitutions can run against a clean string.

When Find-and-Replace Is Not Enough

Three specific cases break the find-and-replace approach:

Homophones in context. A colleague named Pat cannot be replaced from the common word "pat" without breaking every other occurrence of that word in the transcript. Custom vocabulary teaches the model to read context and recognize "Pat" as a name rather than an action.

Inconsistent rendering. Some names confuse models enough that the output varies by paragraph. "Aoife" might appear as "Eva," "Effie," and "Eve" in the same recording. A single substitution rule misses two of the three renderings. Custom vocabulary anchors the model to one consistent output.

Mixed-case tokens and alphanumerics. "Web3," "iOS," "gRPC," "GPT-4o." Find-and-replace works but requires multiple rules because the model produces several capitalisation variants. Custom vocabulary locks the expected output format at inference time.

For deeper patterns in accuracy problems, the post on transcription accuracy explained covers how word error rate is calculated and where errors concentrate.

The Permanent Fix: Custom Vocabulary

Custom vocabulary is preventive rather than reactive. You give the model a list of terms it should recognize, and those terms transcribe correctly on subsequent runs. The implementation varies by platform:

Per vendor documentation, checked July 2026.

A note on Whisper: the OpenAI Whisper API accepts an initial_prompt parameter that biases the model toward expected vocabulary, but the prompt is capped at 224 tokens and the Whisper documentation itself describes this technique as "not especially reliable." If proper nouns are a recurring problem in your work, a platform with first-class custom vocabulary support will serve you better than prompt-engineering Whisper.

My take: for most individual users, Deepgram's keyterm prompting is the easiest to use because it requires no pre-created resource. You pass a list of terms alongside your audio request and the model incorporates them immediately. For teams running hundreds of transcriptions against the same domain vocabulary, AWS Transcribe's named custom vocabulary file approach keeps the list centralized and reusable across all requests.

What Goes in a Good Vocabulary List

Effective lists share a few characteristics:

• 20 to 100 entries is the practical range. Too few and you miss recurring proper nouns; too many and the model starts forcing listed terms into contexts where they do not belong.
• Specific terms, not generic ones. "Convo" is a good entry. "Company" is a bad entry because the model already handles it well.
• Include the unusual, skip the obvious. Guest first names that are common English words ("Mark," "Kate") rarely need vocabulary help. Non-English given names, invented brand names, and technical abbreviations do.
• Update as your content changes. A podcast that covers a new topic area or brings in guests from a new field will encounter new OOV terms. Add them before recording.

Applying This to Specific Workflows

Podcast interview shows

Add every guest's full name and any people they are likely to mention (colleagues, references, co-founders). For technical topics, add the product names, company names, and jargon specific to that episode. Run your substitution list on the raw transcript before editing. The best transcription for podcasts post covers additional accuracy considerations for recorded audio.

Sales and customer calls

Add your product names, your customers' names, the names of competitors you discuss, and the technical terms specific to your domain. These lists tend to stay fairly stable quarter-to-quarter. For meeting transcription, speaker labels combined with correct names cut post-processing time substantially. For how to transcribe a Zoom meeting specifically, the same vocabulary list applies to any platform you record on.

Research interviews

Add all participant names, their institutional affiliations, and the specialized terminology of your research area. For content that will be quoted or cited, errors in names and proper nouns carry higher stakes than in casual notes.

Multi-language content

Custom vocabulary helps with names that a model would otherwise transcribe phonetically in the wrong language's sound system. The fix for multilingual code-switching post covers more on that specific failure pattern.

A Practical Build-Up Workflow

The pattern most regular users settle on:

1. Start with an empty substitution list and an empty vocabulary list.
2. For the first three to five transcripts, scan for mistranscribed names and add them to both.
3. After that initial pass, most recurring proper nouns are covered.
4. Add new names when new people, products, or topics enter your work.
5. If you have API access, move the list into your tool's custom vocabulary feature so it applies at inference time rather than as a post-processing step.

The setup investment is small, under an hour to build a useful initial list, and the return is permanent. Pair this with the fix for technical jargon if your transcripts also contain domain abbreviations and specialized terms.

FAQ

Why does AI transcription keep spelling the same name wrong every time?

The model replaces the unfamiliar name with the closest word in its training distribution every time it hears that sound. It is not random, it is a consistent substitution because the model has learned one phonetically similar word and not the other. Custom vocabulary breaks that habit by telling the model what word to expect.

Does custom vocabulary work for all transcription engines?

Most professional and API-tier tools support some form of it, but the implementation varies. Deepgram Nova-3 and Flux support keyterm prompting (up to 100 terms per request, 500-token cap). AssemblyAI supports keyterms_prompt for batch (up to 1,000 terms) and word_boost with adjustable intensity. Google Cloud Speech-to-Text accepts up to 5,000 phrase hints per request. AWS Transcribe uses named custom vocabulary files (table format, up to 50 KB). Otter Pro offers 100 names plus 100 other terms per user. The OpenAI Whisper API accepts an initial_prompt parameter up to 224 tokens, but its own documentation describes this technique as not especially reliable for proper nouns.

When does find-and-replace break down and I need custom vocabulary instead?

Three cases. First, homophones: if a person named Pat cannot be distinguished from the common word "pat" by position alone, blanket replacement will mangle the common word. Second, inconsistent rendering: if the model outputs "Eva," "Effie," and "Eve" for the same name in the same file, you need multiple substitution rules rather than one. Third, mixed-case tokens like "gRPC" or "GPT-4o": find-and-replace is fragile because the model produces several capitalisation variants and you have to catch them all.

How many terms should I put in a custom vocabulary list?

Most practitioners settle on 20 to 100 entries. Too few and recurring proper nouns slip through; too many and the model can start hallucinating listed terms in contexts where they do not belong. Include specific, unusual terms, names the model would not encounter often in general training data. Skip common words the model already handles well.

Sources

• Deepgram Keyterm Prompting documentation: https://developers.deepgram.com/docs/keyterm (checked July 2026)
• AssemblyAI Streaming Keyterms Prompting: https://www.assemblyai.com/blog/streaming-keyterms-prompting (checked July 2026)
• Otter.ai pricing page, custom vocabulary per tier: https://otter.ai/pricing (checked July 2026)
• Google Cloud Speech-to-Text phrase hints: https://cloud.google.com/speech-to-text/docs/speech-adaptation (checked July 2026)
• AWS Transcribe custom vocabularies: https://docs.aws.amazon.com/transcribe/latest/dg/custom-vocabulary.html (checked July 2026)
• Azure Custom Speech overview: https://learn.microsoft.com/en-us/azure/ai-services/speech-service/custom-speech-overview (checked July 2026)
• OpenAI Whisper prompting guide: https://developers.openai.com/cookbook/examples/whisper_prompting_guide (checked July 2026)