Best Practices for Exporting Audio

Exporting audio is the last thing you do before your work leaves your hands. That makes it one of the most important steps in the chain, and also one of the most commonly rushed. Wrong sample rate, unnecessary stereo files, sloppy naming — these aren’t just housekeeping issues. They cause real problems downstream, whether that’s a rejected deliverable, a confused mixer, or a drive that fills up twice as fast as it should.

Here’s what to get right.

Know what you’re exporting and why

Before you touch the export dialog, know the answers to three questions: Who is receiving this? What will they do with it? What format do they expect?

Exporting for a streaming platform is different from exporting for a mixer, which is different from archiving your session. Those different use cases have different right answers for format, sample rate, bit depth, and whether you need stereo at all. If you export everything at 44.1kHz/16-bit WAV out of habit, you’ll be right sometimes and wrong a lot.

Make these decisions consciously, every time.

Sample rate and bit depth: what to use when

Sample rate

44.1kHz is the standard for music destined for CD or consumer streaming (Spotify, Apple Music, etc.). It’s the native rate for those platforms, and bouncing at 44.1kHz avoids any unnecessary sample rate conversion in the chain.

48kHz is the standard for video — film, TV, podcasts, YouTube, broadcast. Pretty much anything that touches picture. If you’re working in post-production, 48kHz is your default. Period.

88.2kHz and 96kHz are useful during production and for high-res deliverables. Working at 96kHz gives your plugins more headroom to do their processing, and some clients specifically request it. But for most final deliverables, you’ll be converting down anyway — so the question is whether the extra resolution is worth the file size and CPU cost in your session.

192kHz exists. You probably don’t need it.

One note: avoid unnecessary sample rate conversion. If your session runs at 48kHz and your deliverable spec calls for 48kHz, don’t export at 44.1kHz and let the client’s system convert it. Convert intentionally, with a good resampler, when you have to.

Bit depth

16-bit is for final consumer delivery — CD masters, certain streaming uploads. Not for intermediate files. The dynamic range ceiling (96dB) is fine for playback, but too tight for anything that’s still going to be processed.

24-bit is your workhorse. It’s the right choice for session files, stems, final deliverables going to platforms like Netflix or broadcast, and anything that might get touched again. 144dB of dynamic range means you don’t have to worry about headroom.

32-bit float is ideal for raw recording and intermediate files — especially if you’re capturing live sources where levels might be unpredictable. Many modern recorders offer 32-bit float specifically for this reason: you can clip the preamp and recover it in post. But it’s not required for most deliverables, and some clients or platforms won’t accept it. Always check.

The short version: record and work in 24-bit minimum. Deliver in 24-bit unless the spec says otherwise. Only drop to 16-bit when the final destination specifically calls for it.

Stereo vs. mono exports: getting it right

This is where a lot of people leave problems in their wake without realizing it.

If a track is mono — a single microphone, a centered instrument, a voiceover — export it as a mono file. Not a stereo file with the same signal on both channels. Not a “just to be safe” stereo bounce. A mono file.

Why does it matter? A few reasons.

A mono file is half the size of a stereo file carrying the same information. At scale — say, a full foley library or a project with hundreds of tracks — that adds up fast. Storage is not free.

When a mixer, editor, or DAW places a dual mono file (identical L and R) on a stereo track and adds processing, every stereo plugin on that track runs on two channels of the same signal. That’s double the CPU load for zero benefit. On a session with 80 tracks, that accumulates into a real performance problem.

And depending on the downstream system, a stereo file where you expect a mono one can cause panning issues, metadata mismatches, or failed format validation.

The tricky part: you can’t always tell from the file format whether something is true stereo or just a mono signal wrapped in a stereo container. You have to check. Null the channels against each other, look at the waveform, or confirm with a utility plugin. And if you’re dealing with large batches of files — SFX from a vendor, stems from a collaborator, an entire foley library — checking manually doesn’t scale.

Checking for dual mono before you export

Before you export a folder of session audio, it’s worth running a dual mono check. A dual mono file is a stereo WAV where both channels carry identical content — common with Logic exports, field recorder output, and stock SFX libraries. It looks fine in your DAW, plays back fine, but is twice the size it should be and burns double the CPU on every plugin in the chain.

MonoMate is a standalone macOS and Windows app built specifically for this. Drag your files in, it instantly analyzes every one and flags the dual mono cases — including panned files where the channels look different in amplitude but carry the same audio. One click converts them to true mono. It runs outside your DAW, so you can clean up a delivery folder before it ever gets imported.

There’s a free trial if you want to check what’s in your files before committing. More at monomate.app.

The rule is simple: export audio in the channel format that matches its content.

File naming conventions that don’t cause headaches

File names need to communicate three things at a glance: what the file contains, where it belongs, and which version it is.

A naming structure that works well in practice:

ProjectName_TrackDescription_Version_SampleRate-BitDepth.wav

For example:

Avalanche_KickDrum_Stem_v1_48k24b.wav
DocuFilm_VO_Ch01_Final_48k24b.wav
SFX_GlassBreak_Medium_01_48k24b.wav

A few firm rules:

No spaces. Use underscores or hyphens. Spaces break command-line tools, certain DAWs, and more than a few delivery systems.

No special characters. Parentheses, ampersands, slashes — all of these cause problems somewhere in the pipeline. Keep it to alphanumerics, underscores, and hyphens.

Version control in the name. _v1, _v2, _Final, _ClientRevision — something that tells you and everyone else where this file sits in the revision history. Don’t rely on file dates.

Be consistent. Pick a convention and stick to it across your whole project. Mixed naming conventions are worse than bad naming conventions, because they’re unpredictable.

Metadata: what to embed and what to skip

WAV and AIFF files can carry embedded metadata — BWAV (Broadcast Wave) chunks carry timecode, scene, take, and description fields. AIFF has its own metadata structure. For anything going into a post-production workflow, embedded timecode in a BWAV file is genuinely useful: it allows an editor to spot the file at exactly the right place on the timeline.

For music stems going to a mixer, timecode matters less but description fields can still help orient them. Embed the track name, the project name, your name, and the date at minimum.

For SFX libraries, metadata is where organization lives. Tags for category, subcategory, mic perspective, location, and descriptive keywords make a library searchable. If you skip it during recording and intake, you’re doing it later (harder) or not at all.

What to skip: don’t embed custom metadata that only your proprietary system can read if anyone else will be receiving the files. Stick to standard BWF fields that any DAW or asset management tool can parse.

Common export mistakes and how to avoid them

Exporting at the wrong sample rate. Usually means forgetting to change the project setting when working across different deliverable targets. Set a reminder to check the export dialog every time, not just occasionally.

Exporting mono signals as stereo. Very common, especially with SFX and foley. The file is twice as large as it needs to be and costs double the CPU when processed. Check your source material before exporting.

Bouncing with the master chain on. If you’re exporting stems or individual elements, your master bus limiter and any mastering plugins should be bypassed. Those are for the final master, not for intermediates.

No headroom in the export. Aim for peaks around -6 to -3 dBFS on stems and intermediate files, not slammed to 0. Leave the mixer room to work.

Generic file names. Audio 1.wav and Stem Export Final FINAL v2.wav both create problems. The first tells you nothing; the second is a sign the naming convention broke down somewhere. Fix it before it leaves your studio.

Forgetting the format spec. Some platforms want WAV. Some want FLAC. Some have strong opinions about codec settings in AAC or MP3. Always check what the receiving end actually requires before you export.

Checklist

Before you hit export: