Two Ways to Get From Audio to Text
Use local Whisper when you want control over processing and model settings. Use SpeechText.AI when you want to upload a recording and review a transcript without maintaining a Python environment.
OpenAI released Whisper in September 2022. Its original models were trained on 680,000 hours of multilingual, multitask audio, according to the release announcement. Whisper supports speech recognition, language detection, and translation of supported spoken languages into English.
But a speech recognition model is not a complete transcription application. Installing Whisper gets you text and timestamps. It does not automatically give you speaker labels, a transcript editor, or an industry-specific workflow.
- Whisper
- OpenAI's open-source speech-to-text model. It turns audio into recognized text and timing information.
- Speaker diarization
- The process of determining who spoke when. It separates voices into speaker segments; it does not automatically identify people by name.
- Install Python and ffmpeg
- Download Whisper
- Run a transcription command
- Review text and timestamps
Speaker diarization requires extra software.
- Upload to SpeechText.AI
- Select language and domain
- Process in the cloud
- Review speaker-labeled transcript
The Developer Route: Run Whisper Locally With Python and ffmpeg
To transcribe audio locally, install Python, ffmpeg, and the openai-whisper package, then run a command against your recording. The software is free; a GPU is optional, but larger models need substantial computing power for fast transcription.
What you need before installing Whisper
Use Python 3.11 for this walkthrough. You also need a terminal, permission to install software, and an internet connection to download packages and model weights.
- ffmpeg
- Reads and decodes audio. It lets Whisper work with formats such as MP3, WAV, M4A, and audio contained in video files.
- PyTorch
- Runs the neural network. It handles computation on your CPU or a supported GPU.
Leave several gigabytes of disk space for the environment, dependencies, and downloaded models. The largest checkpoints also require substantial working memory. OpenAI's installation documentation is the reference for supported environments.
| Model | Parameters | Approx. GPU VRAM | Practical starting point |
|---|---|---|---|
tiny | 39 million | 1 GB | Quick tests with limited hardware |
base | 74 million | 1 GB | CPU-based experiments |
small | 244 million | 2 GB | A useful accuracy and resource balance |
medium | 769 million | 5 GB | More demanding multilingual work |
large | 1.55 billion | 10 GB | Higher-compute transcription |
GPU memory at a glance
Approximate VRAM in GB. This compares memory requirements, not transcription accuracy or speed.
How to interpret the memory figures
GPU VRAM is different from your computer's main RAM. Precision settings, software versions, and processing options affect actual usage, so treat the table as a starting reference rather than an exact hardware budget.
This is a selection of checkpoints, not an exhaustive list of every Whisper model variant.
For a first run, choose base on a CPU or small on a compatible GPU.
Install Whisper and transcribe your first recording
The commands below use python. On macOS or Linux, substitute python3 if that is your Python 3 command. Long commands can be scrolled horizontally.
-
Create an isolated Python environment
Check your Python version, then create a virtual environment:
Create the environmentpython --version python -m venv .venvActivate it on macOS or Linux:
macOS / Linuxsource .venv/bin/activateOn Windows Command Prompt:
Windows Command Prompt.venv\Scripts\activate.batA virtual environment keeps Whisper's dependencies separate from other Python projects.
-
Install ffmpeg
Use the command for your operating system:
Install ffmpeg by operating system Operating system Installation command macOS with Homebrew brew install ffmpegUbuntu or Debian sudo apt update && sudo apt install ffmpegWindows with winget winget install --id Gyan.FFmpeg --exactIf you installed ffmpeg on Windows, reopen your terminal and reactivate the virtual environment so the updated PATH is available.
Confirm that ffmpeg works:
Verify ffmpegffmpeg -versionIf this command fails, fix the installation before running Whisper.
-
Install the correct Whisper package
Install openai-whisperpython -m pip install --upgrade pip setuptools wheel python -m pip install --upgrade openai-whisperThe package name is openai-whisper, not simply
whisper. -
Run your first transcription
Put a recording named
meeting.mp3in your working folder, or replace the filename with its full path:Transcribe with the small modelwhisper "meeting.mp3" --model small --language en --task transcribe --output_dir transcripts --output_format allThis command selects the multilingual
smallmodel, specifies English speech, and saves the results in a folder namedtranscripts. The first run downloads the model weights. Later runs reuse the cached model.For a CPU-only computer, start with a smaller model and explicitly use CPU-compatible precision:
CPU-only starting commandwhisper "meeting.mp3" --model base --language en --device cpu --fp16 False --output_dir transcripts --output_format all -
Open and review the output
With
--output_format all, Whisper writes:- TXT Plain transcript text.
- SRT + VTT Timestamped subtitle files.
- TSV + JSON Structured transcription data.
Play the recording while checking names, numbers, technical terms, and unclear passages. A cleanly formatted transcript can still contain recognition errors.
Useful Whisper options
You do not need to memorize the command-line interface. Start with a few settings:
| Option | What it does |
|---|---|
--model base | Selects the model checkpoint |
--language en | Specifies English as the spoken language |
--task transcribe | Produces text in the spoken language |
--task translate | Translates supported speech into English |
--output_format srt | Creates a subtitle file |
--word_timestamps True | Requests word-level timing estimates |
--initial_prompt "Vocabulary: acetaminophen, metoprolol" | Supplies contextual text to guide recognition |
Remove --language en to let Whisper detect the language. For a recording with a known language, specifying it avoids unnecessary detection errors. English-only checkpoints such as base.en and small.en are also available.
A vocabulary prompt is not model training
An initial prompt can help with terminology, but it does not turn a general-purpose checkpoint into a medical or legal speech model. It supplies context, not new training. Check prompted terms against the audio.
How to use Whisper from a Python script
Once the command-line version works, the Python interface is short:
import torch
import whisper
device = "cuda" if torch.cuda.is_available() else "cpu"
model = whisper.load_model("base", device=device)
result = model.transcribe(
"meeting.mp3",
language="en",
task="transcribe",
fp16=(device == "cuda"),
)
with open("meeting.txt", "w", encoding="utf-8") as file:
file.write(result["text"])
For batch processing, load the model once and reuse it across recordings. Repeatedly loading a large model wastes time and memory.
This script checks for CUDA, which targets compatible NVIDIA GPUs. It does not automatically activate an Apple GPU.
The real limitations of local Whisper
Fast transcription needs capable hardware
Whisper runs on a CPU, but "it runs" and "it finishes quickly" are different things. Larger models can take longer than the recording's playback duration on a CPU-only laptop.
A powerful compatible GPU makes a major difference. It also introduces another setup layer: drivers, PyTorch builds, and available VRAM.
Check whether PyTorch detects CUDA
python -c "import torch; print(torch.cuda.is_available())"
A result of False is expected on a CPU-only machine. If you have a supported NVIDIA GPU, consult the PyTorch installation selector for the correct build.
Setup can take longer than the transcription
The transcription command is simple. Getting every dependency to cooperate is the hard part. Common problems include an unsupported Python version, ffmpeg missing from PATH, a different environment being active, or PyTorch lacking the expected GPU support. For a one-off recording, fixing those problems can take more effort than the transcription itself.
Raw Whisper does not label speakers
Whisper produces recognized speech and timestamps. It does not provide built-in speaker diarization. A meeting transcript can contain the right sentence without identifying who said it, a serious problem for interviews, action items, and decisions involving several people.
Word timestamps do not solve this. Speaker attribution requires an additional diarization system and logic to align its speaker segments with Whisper's text.
A downloaded checkpoint does not stay current automatically
Whisper launched in 2022, but not every checkpoint dates to that release. Later versions followed, including large-v3 in November 2023.
The important limitation is that a downloaded checkpoint is fixed. It does not automatically learn new product names, current terminology, or changes in how people speak.
Regular updates using fresh, representative audio matter for speech recognition, especially in specialist fields. Still, update frequency alone does not prove better accuracy. Compare the exact model and service on recordings that match your language, vocabulary, microphones, and noise conditions.
Common installation and transcription problems
Check the active environment and the selected model before reinstalling everything. Most first-run failures have a specific, fixable cause.
| Problem | Likely cause | Practical fix |
|---|---|---|
ffmpeg is not recognized | Missing installation or PATH entry | Install ffmpeg, reopen the terminal, and run ffmpeg -version |
whisper is not recognized | Wrong environment or missing command entry point | Activate the environment; try python -m whisper |
| "FP16 is not supported on CPU" | Half-precision inference requested on a CPU | Add --device cpu --fp16 False |
| CUDA out-of-memory error | Model exceeds available GPU memory | Close GPU-heavy applications or choose a smaller model |
| Transcription is very slow | CPU inference or an oversized model | Start with base; use a compatible GPU for heavier workloads |
| Wrong language appears | Language detection error | Set the correct --language value |
| Words appear during silence | Hallucinated text on non-speech audio | Remove long silent sections and verify the surrounding transcript |
The No-Code Route: Transcribe Audio Without a GPU or Code
SpeechText.AI transcribes uploaded audio and video in the cloud, so you do not install Python, configure ffmpeg, or buy a GPU. It adds automatic speaker identification, domain-specific models, and multi-channel audio processing beyond raw Whisper's text output.
Local Whisper makes sense when controlling the model is part of your work. If your actual job is documenting interviews, reviewing calls, or producing meeting records, maintaining a speech recognition environment is extra work.
SpeechText.AI puts the transcription workflow first. You upload the recording, select the relevant settings, and review the result.
How to transcribe audio with SpeechText.AI
-
Upload your audio or video recording
Start with the original recording when available. Repeated compression can remove speech detail. Check the current format, file-size, and duration limits before uploading a large file.
-
Choose the language and relevant domain
Select an available domain-specific model that matches the material, such as medical or legal speech. The right vocabulary context matters more than a generic promise of accuracy.
-
Submit the recording for cloud transcription
Processing happens on the service's infrastructure. Your computer does not need to load a large model or perform GPU inference.
-
Review speaker labels and technical terms
Check labels such as "Speaker 1" and "Speaker 2," then rename them if you know the participants. Review proper names, dates, amounts, and specialist terminology.
-
Edit and export the transcript
Correct unclear passages and choose an available export format suited to your next step, whether that is a document, meeting record, or downstream workflow.
There is no local model installation between you and the upload.
Why speaker identification changes meeting transcription
A block of text tells you what was said. A speaker-labeled transcript also tells you how the conversation unfolded. Consider this exchange:
Raw transcript
Can you send the revised agreement today? Yes. I'll send it before four.
Speaker-labeled transcript
Can you send the revised agreement today?
Yes. I'll send it before four.
Without speaker attribution, the commitment is disconnected from the person who made it. SpeechText.AI's automatic speaker identification adds those distinctions without requiring you to assemble a separate diarization pipeline.
Labels such as "Speaker 1" identify distinct voices; they do not automatically reveal a person's real name. Overlapping speech, similar voices, and poor microphones still deserve a review. Speaker labeling is a useful automation layer, not a reason to skip checking an important record.
Domain-specific AI for medical and legal vocabulary
General speech recognition has to cover an enormous range of audio. Specialist recordings introduce a different challenge: unfamiliar terms that sound like ordinary words. A medication name, procedural phrase, or legal term can be misrecognized even when the surrounding sentence is correct.
SpeechText.AI's domain-specific models focus recognition on professional vocabulary. That makes the service a practical option for medical, legal, and other specialist transcription workflows.
This is a different approach from adding a few words to Whisper's --initial_prompt. A prompt supplies context to a general-purpose model; a domain-specific model addresses the recognition task through its specialization.
Accuracy still needs testing. Use a representative sample containing the terms that matter to your work, then compare corrections required, not just how polished the transcript looks.
Large files and multi-channel recordings
Cloud processing moves the computational workload away from your laptop. You do not need enough local GPU memory to run a large speech model just because the recording is long.
That is useful for lengthy interviews, conference recordings, and video files. But large-file processing is not instantaneous: upload bandwidth, recording duration, service limits, and processing queues affect turnaround.
If participants were recorded on separate channels, preserve those channels for SpeechText.AI's multi-channel audio processing. Mixing them together discards useful separation.
Why separate audio channels matter
A recording with each participant on a separate channel retains information about which microphone captured each voice. That can be useful for speaker attribution and channel-aware processing.
By contrast, the standard Whisper audio-loading workflow converts input to mono. Building channel-aware processing around it requires additional code.
Local Whisper vs. SpeechText.AI: Which Should You Choose?
Choose local Whisper for offline processing and direct control over the model. Choose SpeechText.AI for a cloud transcription workflow with speaker identification and domain-specific models, without maintaining the software yourself.
| Requirement | Local Whisper | SpeechText.AI |
|---|---|---|
| Initial setup | Python, ffmpeg, packages, and model downloads | Cloud upload workflow |
| Computing hardware | Your CPU or compatible GPU | Processing handled in the cloud |
| Speaker labels | Requires an added diarization system | Automatic speaker identification |
| Specialist terminology | General checkpoints with optional prompting | Domain-specific AI models |
| Multi-channel workflow | Additional processing code required | Multi-channel audio processing |
| Offline use | Available after dependencies and models are downloaded | Internet connection required |
| Cost structure | Free software; hardware and operating costs remain | Service pricing and usage limits apply |
| Transcript review | Separate tools or custom development | Review and editing workflow |
Local Whisper
Good reasons to choose it
- Local processing and offline use after setup.
- Model selection, scripting, and batch-processing control.
Trade-offs
- You manage dependencies and hardware.
- Speaker labeling and editing need additional tools.
SpeechText.AI
Good reasons to choose it
- No local Python or GPU setup.
- Speaker identification and specialist models in a cloud workflow.
Trade-offs
- Internet access, service pricing, and usage limits apply.
- Uploaded recordings need a privacy and consent review.
For recurring meetings and specialist recordings, SpeechText.AI removes several tasks that sit outside speech recognition itself. That is the practical difference: less time managing infrastructure and reconstructing conversations.
Prefer the upload route?
Use SpeechText.AI to process your recording in the cloud, then spend your time reviewing the words and speaker labels. Check current pricing and file limits before starting a large project.
