Christopher Abraham home
Christopher Abraham

SEO consultant: technical SEO, indexing, schema, and AI search

How to shrink a huge video to the smallest audio file that still transcribes

By Christopher Abraham · Published

Doodle in red, green, and blue ink: a fat film reel squeezed through a funnel into one thin sound wave

Every transcription tool listens and nothing more, from a web upload box to a speech model on your own laptop. A screen recording or a meeting export carries gigabytes of picture the transcriber throws away. I had a 5.9 GB MP4 of a recorded conversation, and a single ffmpeg command turned it into an audio file of roughly 11 MB per hour that transcribed cleanly. Here is that command, what each flag does, and how I tune it for wherever the file goes next.

On this page
  1. What a transcriber actually hears
  2. Open a terminal
  3. Install ffmpeg
  4. Go to your recording
  5. The command
  6. Pick a bitrate
  7. When a service refuses Opus
  8. Fit under an upload cap
  9. Keep only the part you need
  10. Convert a whole folder
  11. Make it one word
  12. Then transcribe it

What a transcriber actually hears

Whisper, the open speech model inside most of today's transcription products, resamples every file it receives to one channel at 16,000 samples per second before it does anything else. Stereo, 48 kHz audio, and generous bitrates are bytes the model discards on arrival. That gives the target: mono, 16 kHz, encoded with a codec designed around the human voice. Anything more is upload time and storage you pay for and the model never uses.

It also means the original video stays the master. I keep it until the transcript checks out, then decide whether the picture is worth archiving at all.

Open a terminal

Everything in this guide is typed into a terminal, the text window where you give your computer commands. Open one this way:

You type or paste a command at the prompt and press Enter. In a Linux terminal, paste with Ctrl+Shift+V; on a Mac, Cmd+V; in Windows Terminal, Ctrl+V or a right click.

Install ffmpeg

ffmpeg is the free command line converter that sits underneath nearly every other audio and video tool. First see whether you already have it:

ffmpeg -version

If a version banner prints, skip to the next section. If you see "command not found" or "not recognized," install it with the line for your system:

# Linux Mint, Ubuntu, Debian
sudo apt install ffmpeg

# macOS with Homebrew
brew install ffmpeg

# Windows
winget install Gyan.FFmpeg

A few notes so nothing surprises you:

Run ffmpeg -version again. The banner means you're ready. While you're there, confirm your build can write Opus, the codec the main command uses:

ffmpeg -hide_banner -encoders | grep libopus

On Windows, swap grep libopus for findstr libopus. One matching line means you're set. The standard builds for all three systems include it; if yours prints nothing, use the MP3 version further down.

Go to your recording

The terminal works in one folder at a time. Move it to the folder that holds your video and list what's there:

cd ~/Videos
ls

Recordings often land in Videos, Downloads, or Desktop, so swap the folder name as needed. On Windows the same commands work in PowerShell, as in cd $HOME\Videos followed by ls. A shortcut on every system: type cd and a space, drag the folder from your file manager into the terminal window, and press Enter.

Before converting, I check the running time in seconds, which tells me how big the output will be:

ffprobe -v error -show_entries format=duration -of csv=p=0 "recording.mp4"

The command

ffmpeg -i "recording.mp4" -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k -application voip "recording.opus"

Replace both file names with your own, keeping the quotes so names with spaces work. ffmpeg prints a running status line while it works; the time= figure counts up through the recording, and the prompt returns when it's done. Check the result:

ls -lh *.opus

The size should read a few megabytes per hour. Open the file in any media player and listen for a few seconds to confirm the voices came through. My 5.9 GB file came out at well under one percent of its original size, and the transcript lost nothing.

Pick a bitrate

Size is bitrate multiplied by running time, so the arithmetic is easy. For one hour of speech:

Under 16k, the model starts missing mumbled words and the short replies buried in crosstalk. The savings are not worth a worse transcript.

When a service refuses Opus

Some upload forms judge a file by its extension. Opus normally lives inside an Ogg container, so naming the output .ogg gets it past many of them with no other change:

ffmpeg -i "recording.mp4" -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k -application voip "recording.ogg"

MP3 is accepted everywhere. It needs a little more bitrate to stay as clear:

ffmpeg -i "recording.mp4" -vn -ac 1 -ar 16000 -c:a libmp3lame -b:a 32k "recording.mp3"

For apps in the Apple and Microsoft worlds that want M4A:

ffmpeg -i "recording.mp4" -vn -ac 1 -ar 16000 -c:a aac -b:a 32k "recording.m4a"

Fit under an upload cap

Transcription APIs and web apps limit the size of a single upload. OpenAI's speech to text API has capped files at 25 MB for a long time, so check the current figure for whatever you use. At 24k Opus, 25 MB holds a little over two hours. For anything longer, I cut the audio into hour pieces without encoding it again:

ffmpeg -i "recording.opus" -f segment -segment_time 3600 -c copy "recording-part-%02d.opus"

Because -c copy only rewraps the existing audio, the split takes seconds and costs no quality.

Keep only the part you need

Most recordings open with setup chatter. To skip the first ten minutes and keep the next thirty five:

ffmpeg -ss 00:10:00 -i "recording.mp4" -t 00:35:00 -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k -application voip "excerpt.opus"

Placing -ss ahead of -i jumps straight to that point instead of decoding everything before it, which matters on a long file.

Convert a whole folder

for f in *.mp4; do
  ffmpeg -n -i "$f" -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k -application voip "${f%.*}.opus"
done

Run it from inside the folder of recordings. -n refuses to overwrite, so any recording that already has an .opus beside it is skipped. I can rerun the loop safely every time new recordings land in the folder.

Make it one word

The folder loop above and this shortcut are for Linux and macOS. I add a small function to my shell's settings file so I never retype the flags. Open that file in nano, a simple editor that runs inside the terminal:

# Linux
nano ~/.bashrc

# macOS
nano ~/.zshrc

Hold the down arrow to reach the bottom, paste this line, save with Ctrl+O and Enter, then exit with Ctrl+X:

toaudio() { ffmpeg -i "$1" -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k -application voip "${1%.*}.opus"; }

Load the change into the open window with source ~/.bashrc (or source ~/.zshrc on a Mac). New terminals pick it up on their own. From then on the whole conversion is:

toaudio "recording.mp4"

On Windows, the same idea works as a PowerShell loop over a folder:

Get-ChildItem *.mp4 | ForEach-Object { ffmpeg -n -i $_.Name -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k -application voip ($_.BaseName + ".opus") }

Then transcribe it

The small file goes anywhere: a paid service, an API, or a copy of Whisper running on your own machine with nothing uploaded. If you publish audio or video, a reviewed transcript is also plain text that search engines and AI assistants can read and quote, which is why I treat it as part of the page and not an afterthought. For how episode text spreads across the web once it is published, read the show notes cascade.

Sources