Convert Audio for Podcast Platforms

Podcast distribution is largely format-agnostic on the surface — most platforms accept MP3 and M4A — but the details matter. Loudness normalization, mono vs. stereo, and sample rate affect how your show sounds relative to others on Spotify, Apple Podcasts, and Pocket Casts. Platforms apply their own loudness normalization after upload, but starting from a properly normalized source prevents double-normalization artifacts and clipping. This guide covers the full conversion pipeline from raw recording to distribution-ready audio.

Podcast platform audio specifications

Requirements across major distribution platforms:

Spotify for Podcasters (formerly Anchor)

Per Spotify's podcast audio requirements:

• Accepted formats: MP3, M4A, MOV, MP4, M4V, WAV (Spotify transcodes to MP3 for distribution)
• MP3 bitrate: 96–320 kbps; 192 kbps recommended for talk; 256–320 kbps for music-heavy content
• Sample rate: 44.1 kHz
• Channels: Mono recommended for talk podcasts (halves file size, no stereo field needed for voice-only)
• Loudness target: Spotify normalizes to -14 LUFS on playback. Upload at -16 LUFS to leave headroom.
• Max file size: 200 MB per episode via Spotify's direct upload

Apple Podcasts

Per Apple Podcasts audio requirements:

• Accepted formats: MP3, AAC (M4A), WAV, AIFF, FLAC (MP3 strongly recommended for compatibility)
• MP3 bitrate: 128–320 kbps; 192 kbps mono or 256 kbps stereo recommended
• Sample rate: 44.1 kHz
• Channels: Mono for solo/interview, stereo for music podcasts
• Loudness target: Apple normalizes to -16 LUFS on Apple Podcasts; -16 LUFS is the recommended upload target
• ID3 tags: Apple Podcasts reads ID3 v2.3 tags for episode metadata (title, number, artwork)

Buzzsprout / RSS feed hosts

• Accepted formats: MP3, M4A, WAV — MP3 is most universal
• Recommended: MP3, 192 kbps, 44.1 kHz, mono for voice
• Max upload size: Varies by host (Buzzsprout: 500 MB, RSS.com: unlimited on paid plans)

Summary: safe universal target

• Format: MP3
• Bitrate: 192 kbps (mono) or 256 kbps (stereo)
• Sample rate: 44.1 kHz
• Channels: Mono for voice-only, stereo for music
• Loudness: -16 LUFS, true peak -1.5 dBTP

Recommended source-to-target pairs

Conversion commands (curl + Python)

# curl — convert WAV to MP3 for podcast upload
curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key_here" \
  -F "file=@episode-raw.wav" \
  -F "target=mp3" \
  -o episode-ready.mp3

# Convert MP4 video interview to MP3 audio
curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key_here" \
  -F "file=@interview.mp4" \
  -F "target=mp3" \
  -o interview-audio.mp3

import requests
from pathlib import Path

API_KEY = "ctf_sk_your_key_here"

def convert_for_podcast(in_path: str, out_path: str) -> None:
    """Convert audio/video to podcast-ready MP3."""
    with open(in_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": f},
            data={"target": "mp3"},
            timeout=300,
        )
    resp.raise_for_status()
    out = Path(out_path)
    out.write_bytes(resp.content)
    mb = len(resp.content) / 1_000_000
    print(f"{out.name}: {mb:.1f} MB")

convert_for_podcast("episode-raw.wav", "episode-ready.mp3")

For full control over bitrate, loudness normalization, and mono downmix (recommended for distribution-quality output):

# FFmpeg: convert WAV → MP3 192kbps mono, normalize to -16 LUFS
ffmpeg -i episode-raw.wav \
  -af "loudnorm=I=-16:LRA=11:TP=-1.5,aresample=44100" \
  -ac 1 \
  -codec:a libmp3lame -b:a 192k \
  episode-ready.mp3

# FFmpeg: extract audio from Zoom MP4, normalize, export MP3
ffmpeg -i zoom-recording.mp4 \
  -vn \
  -af "loudnorm=I=-16:LRA=11:TP=-1.5" \
  -ac 1 -ar 44100 \
  -codec:a libmp3lame -b:a 192k \
  episode-extracted.mp3

# FFmpeg: convert WAV → M4A AAC (for platforms that prefer AAC)
ffmpeg -i episode-raw.wav \
  -af "loudnorm=I=-16:LRA=11:TP=-1.5" \
  -ac 1 -ar 44100 \
  -codec:a aac -b:a 192k \
  episode.m4a

Batch script: convert a season of episodes for podcast upload

#!/usr/bin/env bash
# Usage: ./convert_podcast_batch.sh ./raw-episodes ./podcast-ready
# Converts WAV, AIFF, M4A, FLAC, MP4 → MP3 192kbps for podcast distribution

API_KEY="ctf_sk_your_key_here"
INPUT_DIR="${1:-.}"
OUTPUT_DIR="${2:-./podcast-ready}"

mkdir -p "$OUTPUT_DIR"
success=0; failed=0

for src in "$INPUT_DIR"/*.{wav,WAV,aiff,AIFF,m4a,M4A,flac,FLAC,mp4,MP4,ogg,OGG}; do
  [ -f "$src" ] || continue
  base=$(basename "$src" | sed 's/\.[^.]*$//')
  out="$OUTPUT_DIR/${base}.mp3"

  printf "%-55s" "$(basename $src) → mp3..."
  code=$(curl -s -o "$out" -w "%{http_code}" \
    -X POST https://changethisfile.com/v1/convert \
    -H "Authorization: Bearer $API_KEY" \
    -F "file=@$src" \
    -F "target=mp3")

  if [ "$code" = "200" ]; then
    mb=$(du -m "$out" | cut -f1)
    echo "OK (${mb} MB)"
    ((success++))
  else
    echo "FAILED (HTTP $code)"
    rm -f "$out"
    ((failed++))
  fi
done

echo ""
echo "Results: $success converted, $failed failed"
echo "Output: $OUTPUT_DIR"
echo "Tip: check loudness with ffprobe or auphonic before distributing."

Podcast platform gotchas

• Loudness normalization matters more than bitrate. Spotify normalizes playback to -14 LUFS, Apple to -16 LUFS. If you upload an episode recorded at -23 LUFS (typical raw recording), the platform will boost it aggressively during normalization — which can amplify background noise and make dynamic range compression artifacts audible. Normalize to -16 LUFS before upload for cleaner results.
• Mono is the right choice for voice-only podcasts. Stereo recording of a single voice is a waste of file size and can cause phase issues if microphones are panned slightly differently. Export solo and interview podcasts in mono (1 channel, 192 kbps). Reserve stereo for shows with music beds or soundscapes.
• Variable bitrate (VBR) vs. constant bitrate (CBR). Most podcast hosts recommend CBR (constant bitrate) MP3 for chapter markers and seek accuracy. VBR is more efficient for music but can cause seek issues in some podcast apps. Use CBR 192k for distribution.
• ID3 tags get read by Apple Podcasts. Episode title, season number, episode number, and artwork embedded in the MP3's ID3 tags are read by Apple Podcasts. If your metadata comes from the RSS feed, embedded ID3 tags can conflict. Use a consistent source — either RSS feed metadata or embedded tags, not both.
• Zoom and Riverside recordings need audio extraction. Zoom cloud recordings save as MP4 video even when audio-only is requested. The audio track is typically AAC at 96 kbps — adequate for voice but not ideal for music. Always record directly to a local audio recorder or interface for higher-quality source material.
• File size affects upload time on hosting platforms. A 1-hour episode at 192 kbps mono is approximately 80 MB. At 320 kbps stereo, the same episode is ~300 MB. Most podcast apps deliver audio at 192 kbps anyway, so high-bitrate uploads cost bandwidth without listener benefit.

Podcast cover art specifications

Podcast artwork has separate requirements from audio — submitted once and used across all platforms:

• Dimensions: 3000×3000 px (required minimum: 1400×1400 px). Apple Podcasts requires 3000×3000 px for featured placements.
• Format: JPEG or PNG
• Color space: RGB (not CMYK)
• File size: Under 512 KB recommended (some hosts have a hard limit)
• Text readability: Must be legible at 55×55 px (the size shown in notification badges). Simple designs with large, bold type outperform intricate illustrated covers at small sizes.

# Convert podcast artwork to spec: 3000x3000 JPEG, sRGB
convert artwork-source.png \
  -resize 3000x3000 \
  -gravity center -extent 3000x3000 \
  -colorspace sRGB \
  -quality 90 \
  podcast-artwork.jpg

Audio format is the unsexy part of podcasting, but it's what listeners hear every episode. A consistent conversion pipeline — WAV/AIFF to MP3 192 kbps CBR mono, normalized to -16 LUFS — means every episode sounds right across Spotify, Apple Podcasts, and every third-party app without extra steps. Free tier covers 1,000 conversions/month.