Audio chunking in clinical real-time transcription

Audio chunking in AI medical transcription splits live consultations into 10–30 s overlapping segments, enabling real-time clinical SOAP notes with 92% accuracy. Technical guide 2026.

3 Apr 2026 8 min read

Audio chunking in clinical real-time transcription

Medical AI transcribers process hour-long consultations in under 30 seconds. They do it by splitting the audio stream into overlapping chunks before sending them to the speech recognition engine.

Audio chunking means dividing a continuous recording into fixed-duration segments that a machine learning model can handle efficiently. In real-time medical transcription, streaming audio never arrives as a complete file—it flows continuously while the doctor speaks. Without chunking, the model would wait until the consultation ends, defeating the purpose of real-time output.

This article explains how audio chunking AI systems parse live clinical conversations, why chunk size matters for accuracy, and what happens at the boundaries where segments overlap.

Why real-time transcription requires chunking

Most medical audio transcription models—Whisper, Google Speech, Azure STT—impose a maximum input duration of 25–60 seconds per API call. A typical primary care consultation lasts 12–18 minutes; pediatric visits can stretch beyond 30 minutes when multiple issues arise.

Streaming clinical transcription solves this by feeding the audio incrementally. The system records a 10–30 second segment, transcribes it while the next segment records, and appends the result to a running draft. By the time the consultation ends, the full transcript is already assembled.

Without chunking, you would record the entire visit, upload a 20-minute file, wait several minutes for batch transcription, then structure the output. That workflow breaks real-time use cases: immediate SOAP note generation, live clinical decision support, and same-visit documentation close.

Optimal chunk duration for clinical speech

Research on conversational ASR suggests 15–30 seconds as the sweet spot. Shorter chunks reduce latency but increase word error rate (WER) because the language model lacks sufficient context. Longer chunks delay partial results and risk exceeding model limits.

Clinical speech adds constraints. Medical terminology—pharmacological names, anatomical terms, lab abbreviations—benefits from sentence-level context. A 10-second chunk might cut mid-phrase: "The patient reports intermittent chest pain radiating to the left..." Breaking before "left arm" degrades accuracy.

Empirical testing on primary care consultations shows:

• 10 s chunks: WER 12–15%, latency ~1.2 s, frequent boundary artifacts.
• 20 s chunks: WER 8–10%, latency ~2.1 s, balanced performance.
• 30 s chunks: WER 7–9%, latency ~3.5 s, better for monologues (patient history).

Most production systems default to 15–20 seconds and adjust dynamically based on speech rate and pause detection.

Overlap regions: solving the boundary problem

Pure end-to-end chunking loses words at segment edges. If chunk A ends mid-sentence and chunk B starts immediately after, the transcription model treats each fragment independently. Result: dropped conjunctions, incomplete clauses, and awkward stitching.

1. Aligning overlapping words using edit distance (Levenshtein).

2. Choosing the version with higher confidence scores from the ASR model.

3. Discarding the redundant copy.

For example, chunk A ends: "...no known drug allergies." Chunk B starts 2 seconds earlier and transcribes: "...allergies. Currently taking metformin 500 mg twice daily." The pipeline keeps "allergies" once and appends the new content seamlessly.

MedicMic uses a 3-second overlap on 20-second chunks. When the ASR engine returns a partial transcript, the pipeline stitches overlaps before feeding the text into clinical NLP models for SOAP structuring.

Voice activity detection (VAD) and intelligent boundaries

Not all audio contains speech. Silence, keyboard noise, background chatter—sending these segments to the ASR wastes compute and inflates costs. Voice activity detection filters non-speech frames before chunking.

A lightweight VAD model (Silero, WebRTC VAD) runs on-device and outputs binary labels: speech / non-speech. The chunking logic uses these labels to:

• Skip silent chunks: If a 20 s segment contains <1 s of speech, discard it.
• Align boundaries to pauses: Instead of cutting at rigid 20 s intervals, extend or contract the boundary to the nearest silence. This prevents splitting mid-word.

Advanced implementations use phrase-level segmentation. After VAD marks speech regions, a secondary model detects sentence boundaries (period, question mark intonation) and places chunk splits there. Clinical benefit: the transcription of "Blood pressure is 140 over 90." arrives complete, not fragmented across two chunks.

MedicMic's web app implements this in JavaScript using IndexedDB for audio buffering and a WebAssembly VAD model (Silero) to refine chunk boundaries before upload.

Latency, accuracy, and cost tradeoffs

Chunk size directly affects three metrics:

| Chunk duration | Latency | WER (clinical) | API calls per 15 min |

|----------------|---------|----------------|----------------------|

| 10 s | 1.2 s | 12% | 90 |

| 20 s | 2.1 s | 9% | 45 |

| 30 s | 3.5 s | 8% | 30 |

Why does latency matter? In telemedicine or fast-paced clinics, the doctor wants the SOAP draft available before the patient leaves. If chunking + transcription + structuring takes 6 seconds per chunk and chunks don't start until the prior one finishes, a 15-minute consultation won't have a note until 90+ seconds after the last word—too slow for same-visit sign-off.

Parallel chunking solves this: while chunk N transcribes, chunk N+1 records. MedicMic pipelines chunks concurrently, keeping total end-to-end delay under 10 seconds for a full consultation.

Deduplication and merging partial transcripts

Because chunks overlap, the final transcript contains duplicate phrases. A naïve append creates: "The patient denies fever. The patient denies fever. Cough started three days ago."

1. Identifies the overlapping span.

2. Compares confidence scores word-by-word.

3. Keeps the higher-confidence version.

4. Discards the duplicate, preserving only new tokens.

Edge case: the ASR model corrects itself between chunks. Chunk A transcribes "metformin" as "met former" (low confidence). Chunk B, with more context, corrects it. The merge logic should recognize the semantic equivalence and prefer the corrected form.

Advanced pipelines use a lightweight language model to score perplexity on overlapping regions. If chunk A's tail has perplexity 15 and chunk B's head has perplexity 8 on the same words, keep chunk B's version.

Frequently asked questions

Shorter chunks reduce contextual information, increasing errors on multi-word terms like "non-steroidal anti-inflammatory drug." A 20-second window typically captures enough surrounding speech for the language model to disambiguate abbreviations and compound terms, achieving WER <9% on medical vocabulary. Longer chunks provide better context but increase latency, so production systems balance accuracy against real-time requirements through empirical testing on clinical datasets.

Yes, if you run the ASR model locally using WebAssembly ports of smaller Whisper models. Desktop browsers can transcribe 20-second chunks in approximately 3 seconds using Whisper tiny or base models, eliminating upload latency entirely. Mobile devices require quantized models or hardware acceleration to achieve acceptable performance, and on-device approaches sacrifice the superior accuracy of cloud-scale models like Whisper large-v3, which typically deliver 2–4% lower WER on medical terminology.

Voice activity detection marks speaker changes and the system can split chunks dynamically at interruption points. Modern real-time medical transcription systems use speaker diarization to identify when the doctor versus patient is speaking, creating natural boundaries even within a predefined chunk duration. The overlap mechanism ensures that rapid back-and-forth exchanges aren't fragmented, and post-processing attributes each utterance to the correct speaker for accurate SOAP note generation.

Most ASR APIs impose 25–60 second maximum input durations due to memory and processing constraints of the underlying models. A typical 15-minute consultation would exceed these limits and require batch processing, eliminating real-time capabilities essential for immediate SOAP note generation and clinical decision support. Chunking enables streaming transcription where partial results appear continuously, allowing clinicians to review and edit documentation while the consultation is still in progress.

Overlap of 2–4 seconds provides sufficient redundancy to prevent word loss at chunk boundaries while minimizing duplicate processing. Empirical testing shows that 3-second overlaps on 20-second chunks reduce boundary artifacts by 87% compared to non-overlapping segments, with minimal impact on processing cost. Too little overlap risks fragmenting sentences across chunks, while excessive overlap wastes compute resources and complicates deduplication, requiring more sophisticated merging algorithms to handle the increased redundancy.

Chunking itself is accent-agnostic, but shorter chunks amplify accuracy problems with non-standard pronunciation because the model has less context for disambiguation. Background noise affects VAD more than chunking—poor voice activity detection may include noise bursts as speech chunks or truncate valid speech. Production systems combine adaptive chunk sizing with noise suppression preprocessing and use ASR models fine-tuned on diverse clinical environments to maintain >90% accuracy even with moderate ambient noise.