Skip to content
Tutorial Reference

How to Get the Duration of Audio Files in Python

Learn how to extract audio duration in Python using libraries like mutagen, pydub, and scipy for formats including MP3, WAV, FLAC, and OGG.

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

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

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

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")

Method 2: Using pydub

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

Installation:

pip install pydub
from pydub import AudioSegment

audio = AudioSegment.from_file("song.mp3")

duration_ms = len(audio)

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 = 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

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}"


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}"


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.

Navigation