How to Convert Audio for Podcasts: Format, Bitrate, and Specs

Publishing a podcast requires getting the audio format right. Not "approximately right" — exactly right. Upload an episode in the wrong format and Apple Podcasts rejects it. Use the wrong bitrate and your episodes sound tinny or consume unnecessary bandwidth. Skip loudness normalization and your podcast sounds dramatically louder or quieter than everything else in a listener's queue. Use stereo for a solo spoken-word show and you double your file sizes for zero benefit.

Every podcast hosting platform and directory has specific technical requirements. These requirements overlap significantly, but the details differ in ways that matter. This guide provides exact specifications for every major platform, clear recommendations for format and bitrate selection, a complete walkthrough of loudness normalization, and practical FFmpeg commands for every step of the podcast audio workflow.

If you are looking for broader audio format recommendations, our best audio format for podcasts guide covers format selection in depth. This guide focuses on the conversion and export process — taking your edited audio and producing files that meet platform specifications.

Platform Requirements at a Glance

Every podcast distribution platform publishes technical requirements for submitted audio. Here are the current specifications:

The safe common denominator across all platforms: MP3, 128 kbps, 44.1 kHz, mono for solo speech or stereo for multi-host/music-heavy content.

Mono vs Stereo for Podcasts

This is one of the most impactful decisions for podcast audio, and many podcasters get it wrong.

When to Use Mono

Use mono for:

• Solo shows (one host, one microphone)
• Interview shows (two people in conversation)
• Most narrative podcasts
• Audiobook-style content
• Any show that is primarily spoken word

When to Use Stereo

Use stereo for:

• Podcasts with significant music content
• Audio dramas with spatial sound design
• Shows featuring binaural recordings
• Live concert or event recordings
• Shows where panning is used as a creative element

Why Mono Is Better for Most Podcasts

The critical point: when you encode stereo speech at 128 kbps, each channel gets only 64 kbps — the same bitrate that sounds acceptable in mono but produces noticeable artifacts in stereo because the encoder has less data per channel. To maintain the same per-channel quality in stereo, you need 256 kbps — doubling file size for zero benefit when the content is identical in both channels.

Converting Stereo to Mono

# Convert stereo to mono
ffmpeg -i stereo_episode.wav -ac 1 mono_episode.wav

# Convert and export to MP3 in one step
ffmpeg -i stereo_episode.wav -ac 1 -c:a libmp3lame -b:a 128k episode.mp3

Loudness Normalization (LUFS)

Loudness normalization is what makes your podcast sound professional. Without it, your episodes will be jarring — either way too loud or too quiet compared to the other podcasts in a listener's queue.

What Is LUFS

LUFS (Loudness Units relative to Full Scale) is the broadcast standard for measuring perceived loudness. Unlike peak levels or RMS, LUFS accounts for how human hearing perceives loudness across different frequencies. A reading of -16 LUFS means the audio is 16 LUFS below digital full scale.

Target Levels

Apple Podcasts recommends -16 LUFS for stereo content. Spotify normalizes to -14 LUFS. The -16 LUFS target is the most widely cited podcast standard and works well across all platforms — Spotify will turn your audio up slightly rather than applying heavy compression.

Measuring Loudness

Before normalizing, measure your current loudness:

ffmpeg -i episode.wav -af loudnorm=print_format=summary -f null -

This outputs integrated loudness (LUFS), true peak (dBTP), and loudness range (LU). If your integrated loudness is already within 1-2 LUFS of your target, you may not need to normalize.

Two-Pass Loudness Normalization

FFmpeg's loudnorm filter supports a two-pass mode for the highest quality normalization:

# Pass 1: Measure (capture the output values)
ffmpeg -i episode.wav -af loudnorm=I=-16:TP=-1.0:LRA=11:print_format=json -f null - 2>&1

# Pass 2: Apply normalization using measured values
ffmpeg -i episode.wav -af loudnorm=I=-16:TP=-1.0:LRA=11:measured_I=-20.5:measured_TP=-2.3:measured_LRA=8.2:measured_thresh=-31.2:offset=-0.3:linear=true -c:a pcm_s16le normalized.wav

Replace the measured_* values with the output from Pass 1.

Single-Pass Normalization (Simpler)

For most podcast workflows, single-pass normalization is sufficient:

ffmpeg -i episode.wav -af loudnorm=I=-16:TP=-1.0:LRA=11 -c:a pcm_s16le normalized.wav

This analyzes the entire file and applies normalization in one pass. The result is slightly less precise than two-pass but entirely adequate for podcast distribution.

Complete Podcast Export Workflow

Here is the complete workflow from edited audio to platform-ready MP3:

Step 1: Loudness Normalization

ffmpeg -i edited_episode.wav -af loudnorm=I=-16:TP=-1.0:LRA=11 -c:a pcm_s16le normalized.wav

Step 2: Convert to Mono (If Applicable)

ffmpeg -i normalized.wav -ac 1 -c:a pcm_s16le mono.wav

Step 3: Export to MP3 with Metadata

ffmpeg -i mono.wav -c:a libmp3lame -b:a 128k -ar 44100 \
  -metadata title="Episode 42: How to Start a Podcast" \
  -metadata artist="The Podcast Show" \
  -metadata album="The Podcast Show" \
  -metadata track="42" \
  -metadata date="2026" \
  -metadata genre="Podcast" \
  -metadata comment="https://example.com/episode-42" \
  episode_42.mp3

All-in-One Command

Combine all steps into a single FFmpeg command:

ffmpeg -i edited_episode.wav \
  -af "loudnorm=I=-16:TP=-1.0:LRA=11" \
  -ac 1 -ar 44100 \
  -c:a libmp3lame -b:a 128k \
  -metadata title="Episode 42: How to Start a Podcast" \
  -metadata artist="The Podcast Show" \
  -metadata album="The Podcast Show" \
  -metadata track="42" \
  -metadata date="2026" \
  -metadata genre="Podcast" \
  episode_42.mp3

Adding Chapter Markers

Chapter markers let listeners jump to specific sections of your episode. Apple Podcasts has supported chapters for years, and Spotify added support in 2024.

MP3 Chapter Markers (ID3 CHAP)

MP3 chapters use the ID3v2 CHAP frame. FFmpeg does not natively write chapter markers to MP3, but you can use tools like mp3chaps or write chapters during encoding from a properly structured input:

# Using ffmpeg with chapter metadata from an input file
# First, create a metadata file (chapters.txt):
;FFMETADATA1
[CHAPTER]
TIMEBASE=1/1000
START=0
END=180000
title=Introduction

[CHAPTER]
TIMEBASE=1/1000
START=180000
END=900000
title=Main Interview

[CHAPTER]
TIMEBASE=1/1000
START=900000
END=1500000
title=Rapid Fire Questions

[CHAPTER]
TIMEBASE=1/1000
START=1500000
END=1800000
title=Closing Thoughts

Then apply chapters during encoding:

ffmpeg -i episode.wav -i chapters.txt -map_metadata 1 \
  -c:a libmp3lame -b:a 128k -ac 1 episode_with_chapters.mp3

M4A Chapter Markers

M4A (AAC) containers have native chapter support that is more reliable:

ffmpeg -i episode.wav -i chapters.txt -map_metadata 1 \
  -c:a aac -b:a 128k -ac 1 episode.m4a

Adding Podcast Cover Art

Episode-specific artwork can be embedded in the MP3 file:

ffmpeg -i episode.wav -i episode_art.jpg -map 0:a -map 1:v \
  -c:a libmp3lame -b:a 128k -ac 1 \
  -c:v copy -metadata:s:v title="Episode Cover" \
  -metadata:s:v comment="Cover (front)" \
  -id3v2_version 3 \
  episode.mp3

Artwork Requirements

The safe choice: 3000x3000 JPEG, square, under 500 KB. This meets all platform requirements.

Batch Processing Episodes

If you are converting an entire back catalog or processing multiple episodes at once:

#!/bin/bash
# Batch convert all WAV episodes to podcast-ready MP3
for wav in episodes/*.wav; do
  filename=$(basename "$wav" .wav)
  ffmpeg -i "$wav" \
    -af "loudnorm=I=-16:TP=-1.0:LRA=11" \
    -ac 1 -ar 44100 \
    -c:a libmp3lame -b:a 128k \
    "output/${filename}.mp3"
done

For large batch operations, our audio converter handles multiple file uploads with consistent settings. See our batch processing guide for more workflow strategies.

Converting from Video to Podcast Audio

Many podcasters record video versions for YouTube and extract audio for podcast distribution. This is a straightforward extraction:

# Extract audio from video, normalize, and export as podcast MP3
ffmpeg -i video_episode.mp4 -vn \
  -af "loudnorm=I=-16:TP=-1.0:LRA=11" \
  -ac 1 -ar 44100 \
  -c:a libmp3lame -b:a 128k \
  podcast_episode.mp3

If the video was recorded at 48 kHz (standard for video), this command resamples to 44.1 kHz (standard for podcast audio). The quality difference is inaudible for speech content.

For more on extracting audio from video, see our video to audio conversion guide and audio extraction guide. Use the MP3 converter or audio converter for an online workflow.

Common Podcast Audio Issues

Episode Sounds Quiet Compared to Other Podcasts

Your loudness is below -16 LUFS. Apply loudness normalization as described above. Measure first, then normalize to -16 LUFS integrated with -1.0 dBTP true peak.

Episode Sounds Distorted or Clipped

True peak levels are exceeding 0 dBTP. The loudnorm filter with TP=-1.0 prevents this, but if your source audio is already clipped, you need to fix the recording — normalization cannot repair distortion that already occurred.

Hissing or Background Noise

Apply noise reduction before export:

# High-pass filter to remove low-frequency rumble + gentle noise gate
ffmpeg -i episode.wav -af "highpass=f=80,afftdn=nf=-25" -c:a pcm_s16le clean.wav

Then normalize and export as usual. For severe noise issues, dedicated tools like iZotope RX or Audacity's noise reduction produce better results than FFmpeg's built-in filters.

File Size Too Large

If your episode exceeds platform limits (200 MB for most):

1. Switch to mono if currently stereo (halves effective bitrate needs)
2. Reduce bitrate from 192 to 128 kbps
3. For very long episodes (3+ hours), 96 kbps mono is acceptable for speech

A 3-hour mono episode at 96 kbps is approximately 126 MB — well within limits.

Inconsistent Volume Between Segments

If your episode has interview segments at different levels, apply compression before normalization:

ffmpeg -i episode.wav -af "acompressor=threshold=-20dB:ratio=3:attack=5:release=50,loudnorm=I=-16:TP=-1.0:LRA=11" -c:a pcm_s16le processed.wav

The compressor reduces the dynamic range (making quiet parts louder and loud parts quieter) before loudness normalization brings everything to the target level.

Quality Checklist Before Publishing

Before uploading your episode to your hosting platform, verify:

• Format is MP3 (128 kbps mono for speech, 192 kbps stereo for music-heavy)
• Sample rate is 44.1 kHz
• Loudness is -16 LUFS integrated (measure with ffmpeg -af loudnorm=print_format=summary)
• True peak is below -1.0 dBTP
• No clipping or distortion in the audio
• Metadata includes episode title, show name, and episode number
• Cover art is embedded (3000x3000 JPEG, square)
• File size is under 200 MB
• Chapter markers are included (if supported by your hosting platform)
• Audio starts cleanly (no dead air or microphone bumps at the beginning)

Use our audio converter for quick format verification and conversion, or the MP3 converter for direct MP3 output. For the full story on podcast audio formats, our best audio format for podcasts guide covers every consideration, and the FLAC vs MP3 comparison explains why lossless formats are not typically used for podcast distribution.