Fast transcription containers with Docker (preview)

The fast transcription container transcribes audio files synchronously, returning results faster than real-time. It's suitable for scenarios where you need transcription results as quickly as possible, such as audio and video subtitles, meeting transcripts, and voicemail. It supports speaker diarization, multichannel processing, and word-level timestamps. This article describes how to download, install, and run a fast transcription container.

For more information about prerequisites, validating that a container is running, running multiple containers on the same host, and running disconnected containers, see Install and run Speech containers with Docker.

Container images

You can find the fast transcription container image for all supported versions and locales on the Microsoft Container Registry (MCR). It resides within the azure-cognitive-services/speechservices/ repository and is named fast-transcription.

The fully qualified container image name is mcr.microsoft.com/azure-cognitive-services/speechservices/fast-transcription. Either append a specific version or append :latest to get the most recent version.

All tags, except for latest, follow this format and are case sensitive:

<language>-gpu-<major>.<minor>.<patch>-preview

For your convenience, the tags are also available in JSON format. The body includes the container path and list of tags. The tags aren't sorted by version, but "latest" is always included at the end of the list as shown in this snippet:

{
  "name": "azure-cognitive-services/speechservices/fast-transcription",
  "tags": [
    <--redacted for brevity-->    
    "gpu-1.0.0-en-us",
    "gpu-1.0.0-en-gb",
    "gpu-1.0.0-en-au",
    "gpu-1.0.0-en-in",
    "gpu-1.0.0-de-de"
  ]
}

Locale support

The following model and locale groups map to supported transcription locales:

Get the container image with docker pull

You need the prerequisites including required hardware. Also see the recommended allocation of resources for each Speech container.

Use the docker pull command to download a container image from Microsoft Container Registry:

docker pull mcr.microsoft.com/azure-cognitive-services/speechservices/fast-transcription:latest

Hardware requirements

The fast transcription container requires a GPU to run.

Run the container with docker run

Use the docker run command to run the container.

docker run --gpus all -p 5000:5000 \
-e ASPNETCORE_URLS=http://+:5000 \
mcr.microsoft.com/azure-cognitive-services/speechservices/fast-transcription \
Eula=accept \
Billing={ENDPOINT_URI} \
ApiKey={API_KEY}

docker run --gpus all -p 5000:5000 \
-e ASPNETCORE_URLS=http://+:5000 \
-v {LICENSE_MOUNT} \
{IMAGE} \
Eula=accept \
Billing={ENDPOINT_URI} \
ApiKey={API_KEY} \
DownloadLicense=True \
Mounts:License={CONTAINER_LICENSE_DIRECTORY} 

docker run --gpus all -p 5000:5000 \
-e ASPNETCORE_URLS=http://+:5000 \
-v {LICENSE_MOUNT} \
-v {OUTPUT_PATH} \
{IMAGE} \
Eula=accept \
Mounts:License={CONTAINER_LICENSE_DIRECTORY} \
Mounts:Output={CONTAINER_OUTPUT_DIRECTORY}

sudo chown -R nonroot:nonroot <YOUR_LOCAL_MACHINE_PATH_1> <YOUR_LOCAL_MACHINE_PATH_2> ...

For more information about docker run with Speech containers, see Install and run Speech containers with Docker.

Use the container

The fast transcription container exposes an HTTP REST API for transcription requests. Unlike the speech-to-text container which supports WebSocket streaming, fast transcription processes complete audio files synchronously.

API endpoints

Send transcription requests to:

POST http://localhost:5000/stt/transcriptions:transcribe

Health check endpoint:

GET http://localhost:5000/stt/health

Audio input limits

Request format

The API accepts multipart/form-data requests with the following structure:

Convert audio to recommended format

If your audio is in a format other than WAV, use ffmpeg to convert it to mono PCM WAV 16-bit 48 kHz:

Convert MP3 to WAV:

ffmpeg -i input.mp3 -ac 1 -ar 48000 -f s16le output.wav

Convert M4A or AAC to WAV:

ffmpeg -i input.m4a -ac 1 -ar 48000 -f s16le output.wav

Convert OPUS to WAV:

ffmpeg -i input.opus -ac 1 -ar 48000 -f s16le output.wav

The flags mean:

• -ac 1: Convert to mono (1 audio channel)
• -ar 48000: Set sample rate to 48 kHz
• -f s16le: Output as 16-bit signed PCM (little-endian)

Request examples

Basic transcription:

curl -X POST "http://localhost:5000/stt/transcriptions:transcribe?api-version=2024-11-15" \
  -F "audio=@audio.wav" \
  -F 'definition={"locales":["en-US"]}'

Dual-channel separation:

curl -X POST "http://localhost:5000/stt/transcriptions:transcribe?api-version=2024-11-15" \
  -F "audio=@stereo.wav" \
  -F 'definition={"locales":["en-US"],"channels":[0,1]}'

Speaker diarization:

curl -X POST "http://localhost:5000/stt/transcriptions:transcribe?api-version=2024-11-15" \
  -F "audio=@meeting.wav" \
  -F 'definition={"locales":["en-US"],"diarization":{"enabled":true}}'

Profanity filter (masked):

curl -X POST "http://localhost:5000/stt/transcriptions:transcribe?api-version=2024-11-15" \
  -F "audio=@audio.wav" \
  -F 'definition={"locales":["en-US"],"profanityFilterMode":"Masked"}'

Health check:

curl http://localhost:5000/stt/health

Transcription options

Response example

{
  "durationMilliseconds": 2029,
  "combinedPhrases": [
    {
      "text": "What's the weather like?"
    }
  ],
  "phrases": [
    {
      "offsetMilliseconds": 40,
      "durationMilliseconds": 1240,
      "text": "What's the weather like?",
      "words": [
        { "text": "What's", "offsetMilliseconds": 40, "durationMilliseconds": 360 },
        { "text": "the", "offsetMilliseconds": 400, "durationMilliseconds": 160 },
        { "text": "weather", "offsetMilliseconds": 560, "durationMilliseconds": 320 },
        { "text": "like?", "offsetMilliseconds": 880, "durationMilliseconds": 400 }
      ],
      "locale": "en-US",
      "confidence": 0.9874588
    }
  ]
}

Response fields

Configuration options

Use the following environment variables to configure the fast transcription container:

Troubleshooting

Recognition delays at end of speech

If you experience latency after you stop speaking, the issue is likely related to silence timeout configuration.

1. Verify you're using the correct timeout properties. The EndSilenceTimeoutMs property controls when the service stops listening after detecting silence. For faster results, reduce this value (the default is typically 500 ms).
2. Ensure your audio format is correctly specified. Audio format mismatches can cause processing delays. Use mono PCM WAV 16-bit 48 kHz for fastest processing.
3. Check that SegmentationSilenceTimeoutMs (used for batch segmentation) isn't being confused with EndSilenceTimeoutMs (used for session termination).

Fragmented or incomplete transcription results

If you receive partial transcription results or fragmented output:

1. Validate audio format first. Confirm your input audio is actually mono PCM 16-bit 48 kHz by checking with ffmpeg info:

   ffmpeg -i input.wav
   

   Look for: Audio: pcm_s16le, 48000 Hz, mono

2. Check audio quality. Ensure the audio file isn't corrupted or doesn't contain long silences between words. Use a tool like Audacity to inspect the waveform.

3. Verify the audio encoding. If you're uploading audio via a URL (audioUrl), ensure the remote endpoint serves the correct Content-Type header (for example, audio/wav).

Unsupported media format error

If you receive an "unsupported media format" error:

Cause: The container detected a mismatch between the file extension, the actual audio codec, or the declared format in your request.

Solutions:

1. Convert the audio to WAV format using ffmpeg (see Convert audio to recommended format).
2. Ensure the file extension matches the actual format (for example, don't name an MP3 file audio.wav).
3. If you're posting audio from a URL, verify the Content-Type header is correct.

Related content

• See the Speech containers overview.
• Review configure containers for configuration settings.
• Use more Azure AI containers.