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.
The Developer Route On your computer
  1. Install Python and ffmpeg
  2. Download Whisper
  3. Run a transcription command
  4. Review text and timestamps

Speaker diarization requires extra software.

The No-Code Route In the cloud
  1. Upload to SpeechText.AI
  2. Select language and domain
  3. Process in the cloud
  4. Review speaker-labeled transcript
The local route runs Whisper itself. The cloud route uses SpeechText.AI as a no-code transcription alternative.

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.

Selected Whisper models: size, GPU memory, and starting use
ModelParametersApprox. GPU VRAMPractical starting point
tiny39 million1 GBQuick tests with limited hardware
base74 million1 GBCPU-based experiments
small244 million2 GBA useful accuracy and resource balance
medium769 million5 GBMore demanding multilingual work
large1.55 billion10 GBHigher-compute transcription

GPU memory at a glance

Approximate VRAM in GB. This compares memory requirements, not transcription accuracy or speed.

Source: OpenAI's published model table. These are reference figures, not guaranteed total-memory budgets.
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.

  1. Create an isolated Python environment

    Check your Python version, then create a virtual environment:

    Create the environment
    python --version
    python -m venv .venv

    Activate it on macOS or Linux:

    macOS / Linux
    source .venv/bin/activate

    On Windows Command Prompt:

    Windows Command Prompt
    .venv\Scripts\activate.bat

    A virtual environment keeps Whisper's dependencies separate from other Python projects.

  2. Install ffmpeg

    Use the command for your operating system:

    Install ffmpeg by operating system
    Operating systemInstallation command
    macOS with Homebrewbrew install ffmpeg
    Ubuntu or Debiansudo apt update && sudo apt install ffmpeg
    Windows with wingetwinget install --id Gyan.FFmpeg --exact

    If you installed ffmpeg on Windows, reopen your terminal and reactivate the virtual environment so the updated PATH is available.

    Confirm that ffmpeg works:

    Verify ffmpeg
    ffmpeg -version

    If this command fails, fix the installation before running Whisper.

  3. Install the correct Whisper package

    Install openai-whisper
    python -m pip install --upgrade pip setuptools wheel
    python -m pip install --upgrade openai-whisper

    The package name is openai-whisper, not simply whisper.

  4. Run your first transcription

    Put a recording named meeting.mp3 in your working folder, or replace the filename with its full path:

    Transcribe with the small model
    whisper "meeting.mp3" --model small --language en --task transcribe --output_dir transcripts --output_format all

    This command selects the multilingual small model, specifies English speech, and saves the results in a folder named transcripts. 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 command
    whisper "meeting.mp3" --model base --language en --device cpu --fp16 False --output_dir transcripts --output_format all
  5. 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:

Whisper command-line settings worth knowing
OptionWhat it does
--model baseSelects the model checkpoint
--language enSpecifies English as the spoken language
--task transcribeProduces text in the spoken language
--task translateTranslates supported speech into English
--output_format srtCreates a subtitle file
--word_timestamps TrueRequests 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:

transcribe.py
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
Check CUDA support
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.

Whisper troubleshooting: symptom, cause, and next step
ProblemLikely causePractical fix
ffmpeg is not recognizedMissing installation or PATH entryInstall ffmpeg, reopen the terminal, and run ffmpeg -version
whisper is not recognizedWrong environment or missing command entry pointActivate the environment; try python -m whisper
"FP16 is not supported on CPU"Half-precision inference requested on a CPUAdd --device cpu --fp16 False
CUDA out-of-memory errorModel exceeds available GPU memoryClose GPU-heavy applications or choose a smaller model
Transcription is very slowCPU inference or an oversized modelStart with base; use a compatible GPU for heavier workloads
Wrong language appearsLanguage detection errorSet the correct --language value
Words appear during silenceHallucinated text on non-speech audioRemove 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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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

Speaker 1:

Can you send the revised agreement today?

Speaker 2:

Yes. I'll send it before four.

Speaker labels connect statements to participants.

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.

Local Whisper and SpeechText.AI compared by requirement
RequirementLocal WhisperSpeechText.AI
Initial setupPython, ffmpeg, packages, and model downloadsCloud upload workflow
Computing hardwareYour CPU or compatible GPUProcessing handled in the cloud
Speaker labelsRequires an added diarization systemAutomatic speaker identification
Specialist terminologyGeneral checkpoints with optional promptingDomain-specific AI models
Multi-channel workflowAdditional processing code requiredMulti-channel audio processing
Offline useAvailable after dependencies and models are downloadedInternet connection required
Cost structureFree software; hardware and operating costs remainService pricing and usage limits apply
Transcript reviewSeparate tools or custom developmentReview 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.