WAV File (.wav): What It Is, How It Works + Sample Files

The basics

What is a WAV file?

A WAV file stores sound the way a computer captures it: a long list of numbers, each one the position of the sound wave at a moment in time, tens of thousands of times per second. Nothing is thrown away, so WAV is the format of choice for recording, editing, mastering and sound effects, and the format many tools use when they hand audio to each other.

The price is size. A minute of CD-quality stereo takes about 10 MB, around 11 times as much as a 128 kbps MP3. That's why WAV is a working format: you record and edit in it, then export a compressed copy (MP3, AAC, Opus) to publish, or a losslessly compressed one (FLAC) to archive.

Strictly speaking, WAV is a container too. Almost every WAV file holds plain PCM samples, but the format code in the header can also announce compressed audio such as µ-law, ADPCM or even MP3, which many programs can't play.

Anatomy

What's inside a WAV file

A WAV file is a RIFF file: a 12-byte header followed by chunks, each with a 4-letter ID, a 4-byte size and its data. All numbers are little-endian, so 44 AC 00 00 means 0x0000AC44, which is 44,100. Here are the real bytes of sample-cd-quality.wav, our 4-second CD-quality sample.

sample-cd-quality.wav (hex)

offset    bytes                                   meaning
0         52 49 46 46                             "RIFF"
4         50 C5 0A 00                             size of the rest: 705,872
8         57 41 56 45                             "WAVE"
12        66 6D 74 20 10 00 00 00                 "fmt " chunk, 16 bytes
20        01 00                                   format 1: PCM
22        02 00                                   2 channels
24        44 AC 00 00                             44,100 samples per second
28        10 B1 02 00                             176,400 bytes per second
32        04 00                                   4 bytes per sample frame
34        10 00                                   16 bits per sample
36        4C 49 53 54 E4 00 00 00 49 4E 46 4F     "LIST" chunk, 228 bytes, "INFO"
48        49 4E 41 4D 23 00 00 00 53 61 6D 70 …   INAM: the title
92        49 41 52 54 …                           IART: the artist
124       49 43 4D 54 …                           ICMT: a comment
214       49 43 52 44 …                           ICRD: the date
228       49 53 46 54 …                           ISFT: the software
272       64 61 74 61 40 C4 0A 00                 "data" chunk, 705,600 bytes
280       00 00 00 00 02 00 03 00 06 00 0B 00 …   samples: L R L R …
705,880                                           end of file

152 49 46 46
The RIFF signature
RIFF in ASCII. The same wrapper is used by AVI video and WebP images, so a file-type detector has to check the form type at byte 8 as well.
250 C5 0A 00
The RIFF size
The size of everything after these 8 bytes: 705,872. Because this is a 32-bit number, a standard WAV file can't be larger than 4 GB.
357 41 56 45
The form type
WAVE says what kind of RIFF file this is. Together with RIFF, it's the signature of a WAV file.
466 6D 74 20 ("fmt ")
The format chunk
Describes the audio. Note the space in its ID: chunk IDs are always 4 characters. In this file it's 16 bytes long, the classic PCM layout; other encodings use 18 or 40 bytes.
501 00 · 02 00 · 44 AC 00 00
Format, channels, sample rate
Format code 1 is linear PCM. Then 2 channels and 44,100 samples per second per channel.
610 B1 02 00 · 04 00 · 10 00
Byte rate, block align, bit depth
176,400 bytes per second (sample rate × channels × bytes per sample), 4 bytes per sample frame (one 16-bit sample for each channel) and 16 bits per sample. Players use the block align to step through the data.
74C 49 53 54 ("LIST")
The metadata chunk
A LIST chunk of type INFO, holding sub-chunks for the title, artist, comment, date and software. Each is a zero-terminated string, padded to an even length.
864 61 74 61 ("data")
The data chunk
The audio itself: 705,600 bytes, which is 4 seconds × 176,400. In this file the samples start at byte 280, not at the usual 44, because the LIST chunk comes first.
900 00 00 00 02 00 03 00
Interleaved samples
Signed 16-bit numbers, left then right for each moment in time: left 0, right 0, then left 2, right 3. The waveform, number by number, with nothing compressed.

Under the hood

How a WAV file is organised: RIFF chunks

Everything in a WAV file is a chunk: a 4-character ID, a 32-bit size and the data. A reader walks the chunks one by one and skips any it doesn't recognise, which is how new kinds of metadata were added over the years without breaking old players. Chunks with an odd size get one padding byte so the next chunk starts on an even offset.

Chunk	Required?	What it holds
`fmt`	Yes	Format code, channels, sample rate, byte rate, block align, bit depth.
`data`	Yes	The samples.
`fact`	For formats other than plain PCM	The number of samples, which can't be worked out from the size of compressed data.
`LIST` / `INFO`	No	Title, artist, comment, date, software and similar text fields.
`bext`	No (required in Broadcast WAV)	Broadcast metadata: description, originator, origination date and time, and a timecode reference.
`cue` , `smpl`	No	Markers, regions and loop points, used by editors and samplers.
`id3`	No	An ID3 tag, as in MP3 files, added by some music software.

The 44-byte header myth

Many code snippets assume the audio starts at byte 44. That's only true for the simplest files, with a 16-byte fmt chunk followed straight away by data. Recorders and editors often put LIST, bext or other chunks in between, so a program that skips 44 bytes reads metadata as sound and plays a click or a burst of noise. Always find the data chunk by walking the chunks.

Variants

Bit depth, sample rate and the formats inside a WAV

The sample rate is how many times per second the wave is measured: 44,100 for CD audio, 48,000 for video, 96,000 or more in some studios. The bit depth is how precisely each measurement is stored, which sets the noise floor: 16-bit gives about 96 dB of dynamic range, 24-bit about 144 dB.

Variant	Format code	Where you'll find it
8-bit PCM (unsigned, silence is 128)	`1`	Old games and telephony. Audibly hissy.
16-bit PCM	`1`	CD audio and most consumer audio.
24-bit PCM	`1` or `FFFE`	Recording and production. Often written with the extensible format.
32-bit floating point	`3` or `FFFE`	Inside audio editors. Values can go above full scale without clipping.
µ-law, A-law (G.711)	`7`, `6`	Telephone systems and voicemail, 8 kHz mono.
Microsoft ADPCM	`2`	Older games and embedded devices.

Code FFFE is WAVE_FORMAT_EXTENSIBLE, a longer 40-byte fmt chunk that Microsoft introduced with Windows 2000 for multichannel audio and higher bit depths. It adds a channel mask that says which speaker each channel is for, the number of bits that are really used, and a GUID naming the actual format. Our sample-24bit-48khz.wav uses it.

Limits

The 4 GB limit, and RF64 and BW64

The RIFF and data sizes are unsigned 32-bit numbers, so a WAV file can't be larger than 4 GB (4,294,967,295 bytes). Some older programs read the size as a signed number and stop at 2 GB. How long 4 GB lasts depends on the format:

Format	Bytes per second	Maximum length in 4 GB
16-bit, 44.1 kHz, stereo	176,400	About 6 h 45 min
24-bit, 48 kHz, stereo	288,000	About 4 h 8 min
32-bit float, 48 kHz, stereo	384,000	About 3 h 6 min
24-bit, 96 kHz, stereo	576,000	About 2 h 4 min
24-bit, 48 kHz, 8 channels	1,152,000	About 62 min

For longer recordings, the European Broadcasting Union defined RF64 (EBU Tech 3306): the file starts with RF64 instead of RIFF, and a ds64 chunk holds 64-bit sizes. Its successor, BW64, is standardised as ITU-R BS.2088. Recorders and audio workstations either switch to one of these past 4 GB or split long recordings into several files. If a long recording opens truncated or not at all, the program may not support RF64.

Related formats

WAV vs AIFF, FLAC and MP3

Format	Compression	Notes
`.wav`	None	Universal, simple, large. The standard on Windows and in most tools.
`.aiff`	None	Apple's equivalent, built on the IFF chunk format with big-endian samples. Common in Mac music software.
`.flac`	Lossless	Decodes back to exactly the same samples, in a smaller file. Better metadata support. For archiving and distribution.
`.mp3`	Lossy	Around a tenth of the size at 128 kbps, with some detail discarded. For listening and sharing.
Broadcast WAV (`.wav`)	None	A WAV with a `bext` chunk, used in radio, TV and archives. Same extension, plays anywhere a WAV does.

Troubleshooting

Common WAV problems and their causes

"Unsupported format" for a file with a .wav extension: the fmt chunk names something other than plain PCM, such as ADPCM, µ-law or 32-bit float, and the player doesn't handle it. Convert it to 16- or 24-bit PCM.
A click or noise burst at the start: a reader assumed a 44-byte header and played metadata as audio.
Plays too fast, too slow or at the wrong pitch: the sample rate in the header doesn't match the audio, often from raw data saved with a guessed header.
A long recording stops partway, or won't open: it passed 4 GB (or 2 GB for some programs) and wasn't written as RF64, or the recorder lost power before it could write the final sizes into the header. Audio editors can usually import the data as raw audio if you know the format.
Distortion after converting a 32-bit float file: float files can hold peaks above full scale. Converting to 16- or 24-bit clips them. Lower the level before converting.
Lost title and artist after copying into a music library: many apps ignore LIST INFO and id3 chunks. Use FLAC if the metadata matters.

How to

How to open, edit and convert a WAV file

Play it: double-click it on Windows (Media Player) or macOS (QuickTime Player or Music), or drag it into a browser. VLC plays almost every variant.
Edit it: Audacity is free on Windows, macOS and Linux. Professional tools include Adobe Audition, Logic Pro, Pro Tools and REAPER.
Inspect it: ffprobe file.wav shows the format, channels, sample rate and metadata; soxi file.wav gives a short summary.
Convert to MP3: ffmpeg -i in.wav -c:a libmp3lame -q:a 2 out.mp3. To FLAC, losslessly: ffmpeg -i in.wav out.flac.
Change the format: ffmpeg -i in.wav -c:a pcm_s16le -ar 44100 out.wav makes a plain 16-bit, 44.1 kHz file that anything can play.

Browsers reliably play 16-bit PCM WAV. Support for other variants, such as µ-law or ADPCM, varies by browser, and WAV files are large to stream, so for a web page an MP3, AAC or Opus copy usually works better.

Free downloads

Sample WAV files to download

Free sample WAV files for testing players, parsers, upload limits and audio pipelines. The sounds are generated chords, sweeps and tones, and every chunk was written by hand so each file is exactly what its description says. All were checked with ffprobe and decoded in full, and the PCM ones also with Python's wave module.

sample-cd-quality.wav · 689.3 KBDownload Open

What's inside sample-cd-quality.wav

A 4-second, CD-quality WAV (16-bit, 44.1 kHz, stereo) with a metadata chunk before the audio, the layout shown in the anatomy above.

The music
Four one-second chords: C, A minor, F and G. The bass note is mostly on the left channel and the upper notes on the right, so you can tell if channels are swapped or merged.
RIFF header
RIFF, the size of the rest of the file, and WAVE.
Format chunk
The classic 16-byte PCM fmt chunk: format 1, 2 channels, 44,100 Hz, 176,400 bytes per second, block align 4, 16 bits.
LIST INFO chunk
Title, artist, a comment naming this page, the year and the software, as INAM, IART, ICMT, ICRD and ISFT. ffprobe shows them as tags.
Data at byte 280
The audio starts at byte 280, not 44, which catches readers that skip a fixed-size header.
Size check
705,600 bytes of audio is exactly 4 × 176,400. The whole file is 705,880 bytes.

All sample WAV files

CD quality: 16-bit, 44.1 kHz, stereo
sample-cd-quality.wav · 689.3 KB (705,880 bytes)
4 seconds of chords with a LIST INFO metadata chunk placed before the data chunk.
- Checking a player or upload form handles standard WAV
- Parsers that must find the data chunk properly
Download Open
24-bit, 48 kHz, WAVE_FORMAT_EXTENSIBLE
sample-24bit-48khz.wav · 562.8 KB (576,350 bytes)
A 2-second sine sweep from 20 Hz to 20 kHz, stereo, with the 40-byte extensible format chunk (format code FFFE, channel mask front left + front right). Turn the volume down: it's a test tone.
- Testing 24-bit and extensible-format support
- Checking frequency response through a pipeline
Download Open
32-bit float, above full scale
sample-float32.wav · 187.8 KB (192,322 bytes)
1 second of a 440 Hz tone, 48 kHz mono, format code 3 with a fact chunk. The first half peaks at 0.4, the second at 1.2, which is above full scale (+1.6 dBFS).
- Testing float WAV support
- Checking how converters handle peaks above 0 dBFS
Download Open
8-bit unsigned, 8 kHz, mono
sample-8bit-8khz.wav · 31.5 KB (32,282 bytes)
4 seconds of chords at telephone quality. In 8-bit WAV, samples are unsigned: silence is 128, not 0.
- Parsers that assume signed samples
- Low-quality and legacy audio paths
Download Open
G.711 µ-law, 8 kHz, mono
sample-mulaw-8khz.wav · 31.5 KB (32,294 bytes)
The same 4 seconds compressed with µ-law (format code 7), the encoding used by telephone networks, with a fact chunk. Not every player supports it.
- Telephony and voicemail pipelines
- Checking what a player does with non-PCM WAV
Download Open
100 KB WAV file
sample-100kb.wav · 100 KB (102,400 bytes)
16-bit, 44.1 kHz mono with the minimal 44-byte header and no metadata, exactly 102,400 bytes.
- Upload and size-limit tests
- The simplest possible WAV parser test
Download Open
1 MB WAV file
sample-1mb.wav · 1 MB (1,048,576 bytes)
About 5.9 seconds of 16-bit, 44.1 kHz stereo chords with a LIST INFO chunk, exactly 1,048,576 bytes (1 MiB).
- Upload limits and timeouts
- Streaming and buffering tests
Download Open

Ways to test with them

Chunk parsing: sample-cd-quality.wav has its audio at byte 280. A reader that starts at byte 44 produces a click at the start.
Format coverage: run the 24-bit, float, 8-bit and µ-law files through your player or converter. Each uses a different format code or sample type, and each one fails differently when it isn't supported.
Clipping: convert sample-float32.wav to 16-bit. The second half should clip (flat-topped waves) unless the level is reduced first.
Upload limits: the 100 KB and 1 MB files have exact sizes, so you can test a limit at the boundary.

Free to use for testing, teaching and demos, commercially or not, with no attribution needed. A link back to this page is always appreciated.

Put it online

Have a WAV file? Give it a link.

Drop a WAV on 99helpers and it gets its own address that plays in the browser, at full quality, with nothing to install. Handy for sending a mix, a voice-over or a sound effect for review.

Put a WAV file online

Questions

WAV files, frequently asked

What does WAV stand for?

Waveform Audio File Format, also called WAVE. It was created by Microsoft and IBM in 1991 and is built on their RIFF container format.

Is WAV lossless?

Almost always. A WAV with PCM audio stores every sample exactly. The format can also hold compressed audio such as µ-law or ADPCM, but those files are uncommon outside telephony and old games.

Why are WAV files so big?

Because the audio isn't compressed. CD-quality stereo needs 176,400 bytes every second, about 10 MB per minute. FLAC makes a smaller file with no loss; MP3 or AAC much smaller with some loss.

WAV or MP3: which is better?

WAV for recording, editing and archiving, because nothing is lost. MP3 (or AAC) for listening and sharing, because it's around a tenth of the size, and at a good bit rate the difference is small.

What's the maximum size of a WAV file?

4 GB, because the format stores sizes as 32-bit numbers. That's about 6 hours 45 minutes of CD-quality stereo. Longer recordings use RF64 or BW64, extensions with 64-bit sizes.

Should I use 16-bit or 24-bit WAV?

24-bit for recording and editing, because the extra headroom and lower noise floor make levels less critical. 16-bit is plenty for a finished mix that people will listen to.

Can a browser play WAV files?

Yes: all current browsers play standard PCM WAV. Variants such as µ-law or ADPCM don't play everywhere, and large WAV files are slow to load, so websites usually use MP3, AAC or Opus.

How do I convert WAV to MP3?

Use Audacity (File → Export → Export as MP3) or FFmpeg: ffmpeg -i in.wav -c:a libmp3lame -q:a 2 out.mp3.

Related formats

Other file types explained

MP3 file All file types

Keep going

Host a WAV file

Put audio online at its own address, playable in any browser.

Share a WAV file

Send audio as a link instead of an attachment.

Hosting guides

How to put different kinds of files online.

Sources

Last reviewed 27 October 2026.