Multilingual Meeting Transcription: Handling Accents and Languages

Your product works fine with English speakers in California. Then a European sales team onboards. Then an Indian engineering team. Then a Singapore customer who code-switches between English and Mandarin mid-sentence. Suddenly your transcription pipeline is producing output that is barely recognizable as the conversation that happened.

Multilingual transcription is not a single problem. It is three overlapping problems: language detection (what language is being spoken?), accent robustness (how well does the model handle non-native English speakers?), and code-switching (what happens when languages mix mid-utterance?). Each requires different technical responses, and none of them are fully solved by any single provider.

The good news is that modern transcription models have improved dramatically on non-English languages and accented English over the past two years. The practical question for a developer building a meeting product is: how do you configure your transcription pipeline to handle a multilingual user base without maintaining separate pipelines for every language combination your users might produce?

In this guide we cover language detection options available through the MeetStream API, provider comparison for non-English language support, best practices for enterprise global deployments, and code examples for auto-detecting language in your recording configuration. Let's get into it.

The Three Problems in Multilingual Meetings

Language detection is the prerequisite problem. If you do not know what language is being spoken, you cannot select the right acoustic model. Most provider APIs assume English by default; passing a German utterance to a model configured for English produces low-confidence garbage. Automatic language detection (sometimes called language identification or LID) runs a classifier over the audio before transcription to determine the dominant language.

Accent robustness is a separate problem from language detection. A native English speaker with a strong Indian, Nigerian, or Scottish regional accent is still speaking English, but the phoneme distribution differs from the American English that most training datasets are weighted toward. Modern neural models trained on diverse multilingual data tend to handle accented English much better than older HMM-based systems, but performance still varies significantly between providers for specific accent groups.

Code-switching is the hardest problem. Real multilingual speakers, particularly in Asia and Africa, frequently switch languages mid-sentence or mid-phrase. This is especially common in technical conversations where domain terms might be in English while surrounding context is in another language. Most models handle code-switching poorly because they are trained on monolingual utterances.

Language Auto-Detection with JigsawStack

JigsawStack's transcription provider supports automatic language detection via the language: "auto" parameter. This runs language identification before transcription and selects the appropriate acoustic model. It is the most hands-off approach for multilingual deployments.

import requests

# Auto-detecting language for a multilingual meeting
bot_payload = {
    "meeting_link": "https://meet.google.com/abc-defg-hij",
    "bot_name": "Global Transcriber",
    "recording_config": {
        "transcript": {
            "provider": "jigsawstack",
            "language": "auto",
            "by_speaker": True
        }
    }
}

response = requests.post(
    "https://api.meetstream.ai/api/v1/bots/create_bot",
    json=bot_payload,
    headers={"Authorization": "Token YOUR_API_KEY"}
)
bot_id = response.json()["bot_id"]
print(f"Bot created with auto language detection: {bot_id}")

The by_speaker: true parameter tells JigsawStack to perform language detection and transcription per-speaker rather than per-meeting. This helps when different participants speak different languages, which is common in global customer calls where the sales rep speaks English and the customer replies in French or Spanish.

Language Detection with Deepgram

Deepgram's nova-3 model supports detect_language: true for automatic language identification. Deepgram's language detection is particularly good for European languages and performs well on accented English. When used with the diarize: true parameter, it also handles per-speaker language detection.

# Deepgram configuration with language detection
bot_payload = {
    "meeting_link": "https://meet.google.com/abc-defg-hij",
    "bot_name": "Multilingual Bot",
    "recording_config": {
        "transcript": {
            "provider": "deepgram",
            "model": "nova-3",
            "diarize": True,
            "detect_language": True
        }
    }
}

response = requests.post(
    "https://api.meetstream.ai/api/v1/bots/create_bot",
    json=bot_payload,
    headers={"Authorization": "Token YOUR_API_KEY"}
)

Provider Comparison for Non-English Languages

Provider capabilities vary significantly across language families. Here is an overview based on documented language support and community benchmarks:

For Southeast Asian languages (Thai, Vietnamese, Indonesian, Tagalog), none of the above providers have production-grade support as of early 2026. If your user base is heavily concentrated in these regions, a provider like Whisper Large-v3 running locally, or a specialized regional provider, may be necessary.

For accented English specifically, all three major providers have improved substantially. Deepgram nova-3 and AssemblyAI universal-2 both handle Indian-accented English, British English, and Australian English at near-native accuracy on clean audio. Performance degrades more sharply than native speakers when background noise is present.

Handling Code-Switching

Code-switching is where current model capabilities have the most room for improvement. The practical workaround is to segment audio at the utterance level and run language detection independently on each utterance before selecting a transcription model. This is more expensive than single-pass processing but produces significantly better results.

import requests
from typing import Optional

def detect_and_transcribe_utterance(
    audio_bytes: bytes,
    sample_rate: int = 16000,
    default_language: str = "en"
) -> dict:
    """
    Detect language of a single utterance and transcribe with the best model.
    Simplified example using Deepgram streaming API directly.
    In practice, route through your transcription provider of choice.
    """
    # Language detection pass (quick, lightweight)
    # For production: use a dedicated LID model like langid or langdetect
    # on the audio features, or use Whisper's language detection output

    # Simplified: detect from first 3 seconds
    language = detect_language_from_audio(audio_bytes, sample_rate)

    # Select provider based on detected language
    provider_config = get_provider_for_language(language)

    return {
        "language": language,
        "provider": provider_config["provider"],
        "config": provider_config
    }

def get_provider_for_language(language_code: str) -> dict:
    """Map detected language code to best provider configuration."""
    european = {"es", "fr", "de", "it", "pt", "nl", "pl"}
    asian = {"zh", "ja", "ko", "hi", "th", "id"}
    arabic = {"ar", "he"}

    if language_code == "en":
        return {"provider": "deepgram", "model": "nova-3"}
    elif language_code in european:
        return {"provider": "deepgram", "model": "nova-3", "language": language_code}
    elif language_code in asian:
        return {"provider": "jigsawstack", "language": language_code}
    elif language_code in arabic:
        return {"provider": "jigsawstack", "language": language_code}
    else:
        return {"provider": "jigsawstack", "language": "auto"}

def detect_language_from_audio(audio_bytes: bytes, sample_rate: int) -> str:
    """Placeholder for language identification logic.
    In production: use Whisper's detect_language() or a dedicated LID model."""
    return "en"  # default fallback

Enterprise Deployment Patterns for Global Teams

For enterprise products serving global teams, a few architectural patterns work well. First, capture language preference at the user or workspace level. When a user sets their preferred language in your application, use that as the primary language hint for transcription. Override only if language detection is highly confident about a different language.

Second, use meeting metadata to inform provider selection before the meeting starts. A calendar invite with French-speaking participants suggests French transcription is needed. You can pull attendee timezones or organizational language from your CRM to pre-configure the bot before it joins.

def create_bot_for_meeting(meeting_link: str, attendees: list, api_key: str) -> dict:
    """
    Create a bot with language config inferred from attendee timezone/location.
    attendees: list of {email, timezone, preferred_language}
    """
    languages = set()
    for attendee in attendees:
        lang = attendee.get("preferred_language", "en")
        if lang:
            languages.add(lang)

    # If all attendees share a single non-English language, configure specifically
    # Otherwise, use auto-detection
    if len(languages) == 1 and "en" not in languages:
        lang = list(languages)[0]
        transcript_config = {
            "provider": "deepgram",
            "model": "nova-3",
            "language": lang,
            "diarize": True
        }
    else:
        transcript_config = {
            "provider": "jigsawstack",
            "language": "auto",
            "by_speaker": True
        }

    response = requests.post(
        "https://api.meetstream.ai/api/v1/bots/create_bot",
        json={
            "meeting_link": meeting_link,
            "bot_name": "Transcriber",
            "recording_config": {
                "transcript": transcript_config
            }
        },
        headers={"Authorization": f"Token {api_key}"}
    )
    return response.json()

Third, store detected language metadata per meeting. Over time, you build a dataset of which languages appear in your product. This data is invaluable for making evidence-based decisions about which providers to invest in and whether you need to implement specialized pipelines for specific language groups.

FAQ

What is the best multilingual transcription provider for meetings with Indian-accented English?

Deepgram nova-3 performs best on Indian-accented English based on community benchmarks. It was trained on a highly diverse dataset including significant representation from South Asian English speakers. AssemblyAI universal-2 is also competitive. The most reliable approach is to run your own WER benchmarks on recordings from your actual user base rather than relying on general benchmarks. See improving transcription accuracy for WER measurement code.

Does accent transcription api handling vary by provider for the same language?

Yes, significantly. Even within a single language like Spanish, performance varies between Castilian Spanish, Latin American Spanish, and Caribbean Spanish dialects. Providers trained on broader Spanish corpora handle this variation better. When deploying to a specific regional market, collect representative test recordings and measure WER for that region specifically before choosing a provider.

How does language detection meeting work when speakers switch languages frequently?

Current production-ready solutions handle code-switching poorly in a single-pass pipeline. The practical approach is to run language detection at the utterance level using a lightweight model like langdetect or the language identification output from Whisper, then route each utterance to the most appropriate transcription model. This is more expensive but produces usable results where single-pass approaches fail.

Can I configure different languages for different participants in the same meeting?

Not directly through a single recording_config. The workaround using live_audio_required is to receive per-speaker audio frames and run language detection and transcription independently per speaker. This gives you full control over per-speaker language configuration. See multi-speaker transcription for the per-speaker audio architecture.

What is the JigsawStack language auto option and when should I use it?

JigsawStack's language: "auto" option runs language identification before transcription and selects the appropriate model automatically. Use it when you have genuine uncertainty about what language will be spoken and you need coverage across a wide language range including Asian and Middle Eastern languages where Deepgram has limited support. The tradeoff is that accuracy on English and European languages is slightly lower than using a language-specific Deepgram or AssemblyAI configuration.