Sample WAV File Download

WAV (Waveform Audio File Format) is an uncompressed PCM audio standard developed by Microsoft and IBM. Unlike MP3 or OGG, it preserves every bit of audio data, making it the ideal format for testing signal processing algorithms and high-fidelity players.

Technical Characteristics

• Bit Depth: Our 16-bit samples provide 96dB of dynamic range, sufficient for almost all testing scenarios.
• Sample Rate: 44100 Hz (CD Quality) is used to ensure compatibility with 99.9% of audio hardware.
• Zero Compression: No artifacts or distortion introduced by lossy encoding algorithms.

Explore the formal specifications at the WAV Header Guide or read about PCM Audio on Wikipedia .

WAV files are used in audio processing pipelines, game engines, music production software, speech recognition testing, and broadcast systems that require lossless audio. The examples below cover four practical use cases with complete runnable code.

How to Read and Analyze a WAV File in Python (pydub)

The pydub library provides a high-level interface for reading and manipulating WAV files. It wraps ffmpeg or libav under the hood and is the most widely used audio processing library in Python.

from pydub import AudioSegment
from pydub.playback import play

audio = AudioSegment.from_wav("sample-44100-stereo-16bit.wav")

print(f"Duration: {len(audio) / 1000:.2f} seconds")
print(f"Sample rate: {audio.frame_rate} Hz")
print(f"Channels: {audio.channels} ({'Stereo' if audio.channels == 2 else 'Mono'})")
print(f"Bit depth: {audio.sample_width * 8} bit")

# Export a 5-second clip
clip = audio[:5000]
clip.export("clip.wav", format="wav")

How to Read WAV Metadata in Python (wave module)

Python's built-in wave module reads WAV headers without any third-party dependencies. This is ideal for quickly inspecting file metadata in automated testing scripts that need to validate audio uploads.

import wave

with wave.open("sample-44100-stereo-16bit.wav", "rb") as f:
    channels = f.getnchannels()
    sample_width = f.getsampwidth()
    frame_rate = f.getframerate()
    n_frames = f.getnframes()
    duration = n_frames / frame_rate

    print(f"Channels: {channels}")
    print(f"Bit depth: {sample_width * 8} bit")
    print(f"Sample rate: {frame_rate} Hz")
    print(f"Duration: {duration:.2f} seconds")
    print(f"File size: ~{n_frames * channels * sample_width / 1024:.0f} KB")

How to Play a WAV File in the Browser (Web Audio API)

The Web Audio API lets you load and play WAV files directly in any modern browser without plugins. This is the foundation for browser-based DAWs, audio editors, and game sound engines.

const ctx = new AudioContext();

fetch("/sample-44100-stereo-16bit.wav")
  .then((res) => res.arrayBuffer())
  .then((buffer) => ctx.decodeAudioData(buffer))
  .then((decodedData) => {
    const source = ctx.createBufferSource();
    source.buffer = decodedData;
    source.connect(ctx.destination);
    source.start(0);
    console.log("Playing: " + decodedData.duration.toFixed(2) + "s");
  });

How to Convert a WAV File to MP3 Using ffmpeg

ffmpeg is the universal command-line tool for audio and video conversion. It handles WAV to MP3, FLAC, AAC, OGG, and dozens of other formats.

# Convert WAV to MP3 at 192 kbps
ffmpeg -i sample-44100-stereo-16bit.wav -b:a 192k output.mp3

# Convert to FLAC (lossless compressed)
ffmpeg -i sample-44100-stereo-16bit.wav output.flac

# Convert stereo to mono
ffmpeg -i sample-44100-stereo-16bit.wav -ac 1 output-mono.wav

# Resample to 48000 Hz (broadcast standard)
ffmpeg -i sample-44100-stereo-16bit.wav -ar 48000 output-48k.wav

Creating a WAV file from scratch requires writing PCM sample data into a RIFF container with the correct headers. Python's built-in wave module handles this entirely without any external dependencies.

Generating a Sine Wave WAV File in Python

import wave
import struct
import math

sample_rate = 44100
duration = 3          # seconds
frequency = 440       # Hz (A4 note)
amplitude = 0.5
n_samples = sample_rate * duration

with wave.open("output.wav", "w") as f:
    f.setnchannels(1)         # mono
    f.setsampwidth(2)         # 16-bit
    f.setframerate(sample_rate)
    for i in range(n_samples):
        t = i / sample_rate
        sample = int(amplitude * 32767 * math.sin(2 * math.pi * frequency * t))
        f.writeframes(struct.pack("<h", sample))

print("WAV file created: 440 Hz sine wave, 3 seconds, 44100 Hz, 16-bit mono")

Recording Audio to a WAV File in Python (pyaudio)

import pyaudio
import wave

CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 5

p = pyaudio.PyAudio()
stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK)

frames = []
for _ in range(int(RATE / CHUNK * RECORD_SECONDS)):
    data = stream.read(CHUNK)
    frames.append(data)

stream.stop_stream()
stream.close()
p.terminate()

with wave.open("recording.wav", "wb") as wf:
    wf.setnchannels(CHANNELS)
    wf.setsampwidth(p.get_sample_size(FORMAT))
    wf.setframerate(RATE)
    wf.writeframes(b"".join(frames))

Common mistakes to avoid: Never try to construct the RIFF header bytes manually in production code. The byte ordering (little-endian) and header field positions are exact and any error will silently corrupt the file. Always use the wave module or a library. For stereo files, interleave left and right channel samples (L R L R L R...) rather than writing all left samples followed by all right samples.