Real-Time Multichannel Speech-to-Text is now generally available

JanGoergen

Microsoft

Nov 09, 2026

Production-ready stereo transcription, now with language identification

In August, we introduced Real-Time Multichannel Speech-to-Text in public preview. It gave contact centers and conversational AI builders a simpler way to transcribe stereo audio without giving up channel separation.

Today, Real-Time Multichannel Speech-to-Text is generally available in Azure Speech, part of Microsoft Foundry. You can now run stereo transcription in production with the same simple Speech SDK integration. This release also adds the capability preview customers asked for most: language identification alongside multichannel.

Since the public preview launched in August, customers have run more than 3 million real-time multichannel sessions, led by contact center workloads in production.

A quick recap: why channel separation matters

In many contact center and communication scenarios, each participant is already recorded on a separate channel. For example, the customer is on one channel and the agent on the other. That separation carries valuable context, especially when people interrupt each other or speak at the same time.

Until now, teams had to choose between two imperfect options. They could split channels and run parallel transcription pipelines, which adds operational overhead. Or they could merge channels into one stream, which can hurt transcription quality and speaker separation.

Real-Time Multichannel Speech-to-Text removes that tradeoff. Azure Speech transcribes up to two channels independently in a single real-time session, and every recognition result is tagged with its source channel.

If the player doesn't load, open the video in a new window: Open video

What’s new at general availability

Production-ready: Real-time multichannel transcription is now generally available and supported for production workloads.

Same price as single channel: Multichannel transcription is priced the same as single-channel real-time transcription, so keeping channels separate doesn't cost more.

Language identification with multichannel: Each channel can be recognized in its own language. For example, an English-speaking agent and a Spanish-speaking customer can be transcribed in the same session, and each result carries both its channel and its detected language.

Works with the features you already use: Diarization, custom speech, semantic segmentation, and TrueText all work with multichannel. Same Speech SDK, recognition events, endpoint, and authentication. One configuration setting turns it on.

Get started

If you already use Azure Speech, getting started is simple. Enable multichannel processing, and optionally add an automatic language detection configuration:

import azure.cognitiveservices.speech as speechsdk
import time

ENABLE_LID = False
done = False
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", endpoint="YourSpeechEndpoint")

# Enable Multichannel processing
speech_config.set_property(speechsdk.PropertyId.Speech_EnableMultiChannelProcessing, "true")

# Optional: identify the language on each channel
auto_detect_config = None
if ENABLE_LID:
    speech_config.set_property(speechsdk.PropertyId.SpeechServiceConnection_LanguageIdMode, "Continuous")
    auto_detect_config = speechsdk.languageconfig.AutoDetectSourceLanguageConfig(languages=["en-US", "es-MX"])
else:
    speech_config.speech_recognition_language = "en-US"

audio_config = speechsdk.AudioConfig(filename="stereo.wav")
speech_recognizer = speechsdk.SpeechRecognizer(
    speech_config=speech_config,
    auto_detect_source_language_config=auto_detect_config,
    audio_config=audio_config,
)

# Print Multichannel results
def recognized_cb(evt: speechsdk.SpeechRecognitionEventArgs) -> None:
    if evt.result.reason == speechsdk.ResultReason.RecognizedSpeech:
        label = f"channel {evt.result.channel}"
        if ENABLE_LID:
            label += f" | {speechsdk.AutoDetectSourceLanguageResult(evt.result).language}"
        print(f"RECOGNIZED ({label}): {evt.result.text}")

def stop_cb(evt: speechsdk.SessionEventArgs) -> None:
    global done
    done = True

speech_recognizer.recognized.connect(recognized_cb)
speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)

speech_recognizer.start_continuous_recognition()
try:
    while not done:
        time.sleep(0.5)
finally:
    speech_recognizer.stop_continuous_recognition()

To also identify individual speakers within a channel, use ConversationTranscriber instead of SpeechRecognizer. Each result then includes both the channel and the speaker ID.

Built for real-world conversations

Contact centers and CCaaS platforms: Keep agent and customer audio separate for agent assist, quality monitoring, compliance, and post-call analytics, without running two pipelines.

Multilingual customer service: Language identification lets each side of the call be transcribed in its own language, ready for translation, summarization, or routing.

Conversational AI: Channel-aware transcripts give voice agents and copilots a cleaner record of who said what for downstream reasoning and summarization.

Good to know

Supports up to two channels, with continuous recognition.

Heavily overlapping speech on both channels can increase result latency.

Phrase lists, multilingual models, post-stream refinement, and pronunciation assessment aren't supported with multichannel in this release.

Requires Speech SDK 1.51 or later. For Go, and for channel metadata on diarization results in JavaScript, use version 1.52 or later.

Get started today

Real-Time Multichannel Speech-to-Text is now generally available in Azure Speech. If you’ve been choosing between parallel pipelines and mixed-audio compromises, you can now keep stereo channel separation in production, with built-in language identification.