How to Get the Duration of Audio Files in Python

Retrieving the duration of audio files is a common requirement in media applications, audio processing pipelines, podcast tools, and music libraries. Python provides several libraries to extract audio duration along with other metadata.

In this guide, we'll cover multiple methods to get audio file duration, supporting formats like WAV, MP3, FLAC, OGG, and more.

Quick Answer: Using mutagen

from mutagen import File

audio = File("song.mp3")
duration = audio.info.length
print(f"Duration: {duration:.2f} seconds")

Output:

Duration: 245.67 seconds

Method 1: Using mutagen (Recommended)

Mutagen is a versatile library that handles audio metadata for many formats including MP3, WAV, FLAC, OGG, M4A, and more.

Installation:

pip install mutagen

For WAV Files

from mutagen.wave import WAVE

audio = WAVE("alarm.wav")
duration_seconds = audio.info.length

# Convert to minutes and seconds
minutes = int(duration_seconds // 60)
seconds = int(duration_seconds % 60)

print(f"Duration: {minutes}:{seconds:02d}")
print(f"Duration: {duration_seconds:.2f} seconds")

Output:

Duration: 0:02
Duration: 2.45 seconds

For MP3 Files

from mutagen.mp3 import MP3

audio = MP3("song.mp3")
print(f"Duration: {audio.info.length:.2f} seconds")
print(f"Bitrate: {audio.info.bitrate // 1000} kbps")
print(f"Sample rate: {audio.info.sample_rate} Hz")

Output:

Duration: 245.67 seconds
Bitrate: 320 kbps
Sample rate: 44100 Hz

For Any Format (Auto-Detect)

from mutagen import File

def get_duration(filepath):
    """Get audio duration for any supported format."""
    audio = File(filepath)
    if audio is None:
        raise ValueError(f"Unsupported or invalid file: {filepath}")
    return audio.info.length

# Works with any format mutagen supports
print(f"MP3:  {get_duration('song.mp3'):.2f}s")
print(f"WAV:  {get_duration('alarm.wav'):.2f}s")
print(f"FLAC: {get_duration('track.flac'):.2f}s")

tip

mutagen.File() auto-detects the file format, making it the most convenient option when you need to handle multiple audio formats.

Method 2: Using pydub

Pydub is a simple audio manipulation library that makes getting duration straightforward.

Installation:

pip install pydub

info

Pydub requires FFmpeg for non-WAV formats. Install it via your system package manager:

• Ubuntu: sudo apt install ffmpeg
• macOS: brew install ffmpeg
• Windows: Download from ffmpeg.org and add to PATH

from pydub import AudioSegment

# Load audio file
audio = AudioSegment.from_file("song.mp3")

# Duration in milliseconds
duration_ms = len(audio)

# Convert to seconds
duration_sec = duration_ms / 1000

minutes = int(duration_sec // 60)
seconds = int(duration_sec % 60)

print(f"Duration: {duration_ms} ms")
print(f"Duration: {duration_sec:.2f} seconds")
print(f"Duration: {minutes}:{seconds:02d}")

Output:

Duration: 245670 ms
Duration: 245.67 seconds
Duration: 4:05

Method 3: Using scipy.io.wavfile (WAV Only)

For WAV files, scipy can read the audio data and compute duration from the sample rate and data length, without extra packages needed beyond scipy.

Installation:

pip install scipy

from scipy.io import wavfile

sample_rate, data = wavfile.read("alarm.wav")

# Duration = number of samples / sample rate
duration = len(data) / sample_rate

print(f"Sample rate: {sample_rate} Hz")
print(f"Samples: {len(data)}")
print(f"Duration: {duration:.2f} seconds")

Output:

Sample rate: 44100 Hz
Samples: 108045
Duration: 2.45 seconds

caution

scipy.io.wavfile only supports WAV files. For other formats, use mutagen, pydub, or audioread.

Method 4: Using wave (Built-in, WAV Only)

Python's built-in wave module requires no installation and works for WAV files:

import wave

with wave.open("alarm.wav", "r") as audio:
    frames = audio.getnframes()
    rate = audio.getframerate()
    channels = audio.getnchannels()
    duration = frames / float(rate)

    print(f"Channels: {channels}")
    print(f"Frame rate: {rate} Hz")
    print(f"Frames: {frames}")
    print(f"Duration: {duration:.2f} seconds")

Output:

Channels: 2
Frame rate: 44100 Hz
Frames: 108045
Duration: 2.45 seconds

Method 5: Using audioread (Cross-Format)

Audioread uses whatever audio backend is available on your system.

Installation:

pip install audioread

import audioread

with audioread.audio_open("song.mp3") as f:
    print(f"Duration: {f.duration:.2f} seconds")
    print(f"Channels: {f.channels}")
    print(f"Sample rate: {f.samplerate} Hz")

Output:

Duration: 245.67 seconds
Channels: 2
Sample rate: 44100 Hz

Formatting Duration for Display

Here's a reusable function that converts seconds to a human-readable format:

def format_duration(seconds):
    """Convert seconds to HH:MM:SS or MM:SS format."""
    seconds = int(seconds)
    hours = seconds // 3600
    minutes = (seconds % 3600) // 60
    secs = seconds % 60

    if hours > 0:
        return f"{hours}:{minutes:02d}:{secs:02d}"
    return f"{minutes}:{secs:02d}"


# Examples
print(format_duration(2.45))      # 0:02
print(format_duration(245.67))    # 4:05
print(format_duration(3725.5))    # 1:02:05

Output:

0:02
4:05
1:02:05

Complete Example: Batch Processing Audio Files

Here's a practical script that gets the duration of all audio files in a directory:

from pathlib import Path
from mutagen import File


def get_audio_info(filepath):
    """Get duration and basic info for an audio file."""
    audio = File(str(filepath))
    if audio is None:
        return None
    return {
        "file": filepath.name,
        "duration": audio.info.length,
        "formatted": format_duration(audio.info.length),
    }


def format_duration(seconds):
    seconds = int(seconds)
    hours = seconds // 3600
    minutes = (seconds % 3600) // 60
    secs = seconds % 60
    if hours > 0:
        return f"{hours}:{minutes:02d}:{secs:02d}"
    return f"{minutes}:{secs:02d}"


# Scan a directory for audio files
audio_extensions = {'.mp3', '.wav', '.flac', '.ogg', '.m4a', '.wma'}
audio_dir = Path("./music")

total_duration = 0

for filepath in sorted(audio_dir.iterdir()):
    if filepath.suffix.lower() in audio_extensions:
        info = get_audio_info(filepath)
        if info:
            total_duration += info["duration"]
            print(f"  {info['formatted']:>8}  {info['file']}")

print(f"\n  {'Total':>8}: {format_duration(total_duration)}")

Output:

      0:02  alarm.wav
      3:45  intro.mp3
      4:05  song.mp3
      5:12  track.flac

     Total: 13:04

Method Comparison

Method	Formats	Installation	Accuracy	Best For
mutagen	MP3, WAV, FLAC, OGG, M4A, etc.	pip install mutagen	⭐⭐⭐	General use (recommended)
pydub	All (via FFmpeg)	pip install pydub + FFmpeg	⭐⭐⭐	Audio manipulation + duration
wave	WAV only	Built-in	⭐⭐⭐	Simple WAV processing
scipy	WAV only	pip install scipy	⭐⭐⭐	Scientific audio analysis
audioread	Multiple (backend-dependent)	pip install audioread	⭐⭐	Cross-platform decoding

Conclusion

To get the duration of audio files in Python, mutagen is the most versatile and recommended library: it supports many formats, doesn't require external tools like FFmpeg, and provides additional metadata like bitrate and sample rate.

• For WAV-only needs, Python's built-in wave module works without any installation.
• For projects that also need audio manipulation (cutting, merging, effects), pydub is ideal since you get duration as part of loading the audio.

Whichever method you choose, the duration is always returned in seconds and can be easily formatted into a human-readable MM:SS or HH:MM:SS string.