Learn how to trim audio files with lossless MP3 cutting, FFmpeg commands, and online tools. Cut audio for ringtones, podcast editing, sample extraction, and more with step-by-step instructions.
Free, in your browser — no signup, files auto-delete in 2 hours.
Trimming audio is one of the most common editing tasks. You recorded a podcast and need to cut the first 30 seconds of silence and chatter before the intro. You want a 30-second clip from a song as a ringtone. You need to extract a specific quote from a 2-hour interview for a presentation. You downloaded a sound effect that has 5 seconds of silence at the tail that you need to remove.
The tool you use and the method you choose matter more than you might think. Trimming an MP3 file incorrectly re-encodes the entire track, introducing a generation of lossy compression artifacts. Trimming without considering frame boundaries produces glitches at the cut points. And trimming without proper fade-in/fade-out creates harsh pops and clicks.
This guide covers every trimming scenario: lossless MP3 cutting, FFmpeg-based precision trimming for any format, online tools for quick cuts, and specialized workflows for ringtones, podcast editing, and sample extraction.
MP3 files are divided into frames, each containing a fixed duration of audio (typically 26 milliseconds for 44.1 kHz). Because MP3 is a lossy format, re-encoding introduces additional quality loss. The ideal approach is to trim without re-encoding — cutting at frame boundaries so the audio data is never decoded and re-encoded.
When you trim an MP3 in a regular audio editor (Audacity, GarageBand, etc.), the editor:
Step 3 is the problem. Every MP3 encoding pass permanently removes audio data. Re-encoding an already-lossy MP3 compounds the loss. The result is measurably (and sometimes audibly) worse than the original.
Lossless MP3 cutting skips the decode/re-encode cycle entirely. It identifies the MP3 frames that fall within your desired time range and copies them directly. The audio data is never touched — it is bit-for-bit identical to the corresponding segment of the original file.
FFmpeg's -c copy flag enables lossless stream copying:
# Cut from 0:30 to 3:45 without re-encoding
ffmpeg -i input.mp3 -ss 00:00:30 -to 00:03:45 -c copy output.mp3
This copies the MP3 frames within the specified range. The cut points may be adjusted slightly (up to ~26ms) to align with frame boundaries, but the audio quality is perfectly preserved.
FFmpeg supports two seeking modes:
# Input seeking (fast, may be slightly imprecise for MP3)
ffmpeg -ss 00:00:30 -i input.mp3 -to 00:03:15 -c copy output.mp3
# Output seeking (slower, more accurate)
ffmpeg -i input.mp3 -ss 00:00:30 -to 00:03:45 -c copy output.mp3
When -ss comes before -i, FFmpeg seeks in the input stream — faster but may land on the nearest keyframe rather than the exact timestamp. When -ss comes after -i, FFmpeg decodes from the beginning and starts output at the precise position — slower but more accurate.
For lossless MP3 cutting, the difference is minimal (at most one frame, ~26ms). For precise editing requirements, use output seeking.
Pro Tip: When you need frame-accurate cutting in MP3 without re-encoding, the maximum timing error is one MP3 frame (about 26 milliseconds). This is imperceptible for virtually all use cases. Only re-encode if you need sample-accurate precision, and if you do, encode from the original lossless source rather than from the MP3.
FFmpeg handles trimming for every audio format. The basic syntax is the same:
# Trim WAV from 1:00 to 2:30
ffmpeg -i input.wav -ss 00:01:00 -to 00:02:30 -c copy output.wav
# Trim FLAC (lossless, no re-encoding needed)
ffmpeg -i input.flac -ss 00:01:00 -to 00:02:30 -c copy output.flac
# Trim AAC/M4A
ffmpeg -i input.m4a -ss 00:01:00 -to 00:02:30 -c copy output.m4a
# Trim OGG Vorbis
ffmpeg -i input.ogg -ss 00:01:00 -to 00:02:30 -c copy output.ogg
# Extract 45 seconds starting from 2:00
ffmpeg -i input.mp3 -ss 00:02:00 -t 45 -c copy output.mp3
The -t flag specifies duration instead of end time. Use whichever is more convenient.
# Extract the last 60 seconds
ffmpeg -sseof -60 -i input.mp3 -c copy last_minute.mp3
The -sseof flag seeks relative to the end of the file. -sseof -60 means "start 60 seconds before the end."
Extract several segments from a single file:
# Extract three segments
ffmpeg -i interview.mp3 -ss 00:05:30 -to 00:07:15 -c copy segment1.mp3
ffmpeg -i interview.mp3 -ss 00:22:00 -to 00:24:30 -c copy segment2.mp3
ffmpeg -i interview.mp3 -ss 00:45:00 -to 00:48:00 -c copy segment3.mp3
Hard cuts at trim points can produce audible pops or clicks, especially if the trim point falls mid-waveform. Adding a short fade eliminates this artifact.
# Trim with 0.5-second fade in and 1-second fade out
ffmpeg -i input.mp3 -ss 00:01:00 -to 00:03:00 \
-af "afade=t=in:d=0.5,afade=t=out:st=119:d=1" \
-c:a libmp3lame -b:a 320k output.mp3
Note: Adding fades requires re-encoding because the audio data is being modified. Use the highest quality settings to minimize quality loss. The st parameter in the fade-out filter is the start time (relative to the output) of the fade.
When joining trimmed segments, a crossfade creates a smooth transition:
ffmpeg -i segment1.mp3 -i segment2.mp3 -filter_complex \
"acrossfade=d=2:c1=tri:c2=tri" \
-c:a libmp3lame -b:a 320k joined.mp3
This creates a 2-second crossfade using a triangular curve. For podcast editing, a 0.5-1 second crossfade sounds natural for speech transitions.
Creating ringtones requires specific formatting for iOS and Android.
iPhone ringtones use the M4R format (AAC audio in an M4A container, renamed to .m4r). Maximum duration is 30 seconds for ringtones and 40 seconds for alert tones.
# Create iPhone ringtone
ffmpeg -i song.mp3 -ss 00:01:15 -t 30 \
-c:a aac -b:a 256k \
-af "afade=t=in:d=0.5,afade=t=out:st=29:d=1" \
ringtone.m4r
Android supports MP3 ringtones directly. No special format conversion is needed:
# Create Android ringtone
ffmpeg -i song.mp3 -ss 00:01:15 -t 30 \
-c:a libmp3lame -b:a 192k \
-af "afade=t=in:d=0.3,afade=t=out:st=29:d=1" \
ringtone.mp3
| Platform | Format | Max Duration | Recommended Bitrate | Fade |
|---|---|---|---|---|
| iPhone (ringtone) | M4R (AAC) | 30 seconds | 256 kbps | 0.5s in, 1s out |
| iPhone (alert) | M4R (AAC) | 40 seconds | 256 kbps | 0.3s in, 0.5s out |
| Android | MP3 | No limit | 192 kbps | 0.3s in, 1s out |
| Android | OGG | No limit | 192 kbps | 0.3s in, 1s out |
Pro Tip: Choose a ringtone segment that starts with a distinctive sound — something you will recognize immediately even in a noisy environment. Avoid segments that start softly and build gradually, as you may miss the beginning of the ring. The best ringtone clips start with a strong, recognizable musical phrase.
Podcast editing often involves trimming multiple files and combining segments. Here are common podcast trimming workflows.
# Automatically detect and remove leading/trailing silence
ffmpeg -i raw_episode.wav \
-af "silenceremove=start_periods=1:start_silence=1:start_threshold=-40dB,areverse,silenceremove=start_periods=1:start_silence=1:start_threshold=-40dB,areverse" \
-c:a pcm_s16le trimmed.wav
This filter removes silence from both the beginning and end. The threshold (-40dB) determines what counts as "silence" — adjust if your recording has low-level background noise.
# Detect silence and output timestamps
ffmpeg -i episode.wav -af silencedetect=noise=-30dB:d=2 -f null - 2>&1 | grep "silence_"
This outputs timestamps where silence occurs (silence longer than 2 seconds at less than -30dB). You can use these timestamps to split the recording at natural pause points.
After editing individual segments, join them into the final episode:
# Create file list
echo "file 'intro.wav'" > segments.txt
echo "file 'interview_part1.wav'" >> segments.txt
echo "file 'midroll.wav'" >> segments.txt
echo "file 'interview_part2.wav'" >> segments.txt
echo "file 'outro.wav'" >> segments.txt
# Concatenate
ffmpeg -f concat -safe 0 -i segments.txt -c copy final_episode.wav
Then export to MP3 for distribution:
ffmpeg -i final_episode.wav -c:a libmp3lame -b:a 128k -ac 1 \
-metadata title="Episode 42: Topic Name" \
-metadata artist="Podcast Name" \
episode_42.mp3
For detailed podcast format requirements, see our best audio format for podcasts guide and podcast audio conversion guide.
Extracting audio samples from longer recordings requires precision and quality preservation.
# Extract a single hit (0.5 seconds starting at 14.2 seconds)
ffmpeg -i drum_recording.wav -ss 14.2 -t 0.5 -c copy drum_hit.wav
For clean sample boundaries, trim at zero crossings to avoid clicks:
# Apply a very short fade to ensure clean boundaries
ffmpeg -i recording.wav -ss 14.2 -t 0.5 \
-af "afade=t=in:d=0.002,afade=t=out:st=0.498:d=0.002" \
-c:a pcm_s24le sample.wav
A 2-millisecond fade is inaudible but eliminates any click from a non-zero-crossing cut.
If you have a list of sample start times:
#!/bin/bash
# Extract samples at defined timestamps
while IFS=, read -r start duration name; do
ffmpeg -i source.wav -ss "$start" -t "$duration" -c copy "samples/${name}.wav"
done << EOF
0.5,0.3,kick
1.2,0.2,snare
2.0,1.5,hihat_roll
3.8,0.8,crash
EOF
For more on audio extraction workflows, see our audio extraction from video guide.
For quick trims without installing software, ConvertIntoMP4's audio converter supports trimming during conversion. Upload your audio file, set the start and end times, select your output format, and download the trimmed result.
This is particularly useful when you also need to convert formats — for example, trimming a WAV file and converting to MP3 simultaneously, or extracting a segment from a FLAC file and exporting as AAC.
For format-specific converters:
Extract a segment and change its speed (useful for transcription):
# Extract and slow down to 75% speed
ffmpeg -i lecture.mp3 -ss 00:15:00 -to 00:16:00 \
-af "atempo=0.75" -c:a libmp3lame -b:a 192k slow_segment.mp3
Extract a segment and normalize its volume:
# Trim and normalize to -16 LUFS
ffmpeg -i recording.wav -ss 00:05:00 -to 00:10:00 \
-af "loudnorm=I=-16:TP=-1.5:LRA=11" \
-c:a pcm_s16le normalized_segment.wav
If you have multiple recordings of the same event (different microphones), trim them all identically:
#!/bin/bash
START="00:05:30"
END="00:45:00"
for file in mic_*.wav; do
ffmpeg -i "$file" -ss "$START" -to "$END" -c copy "trimmed_${file}"
done
To cut out a section (like an unwanted cough or interruption) without removing the beginning or end:
# Remove section from 5:00 to 5:15 (keep everything else)
ffmpeg -i input.mp3 -filter_complex \
"[0]atrim=end=300[a]; \
[0]atrim=start=315,asetpts=PTS-STARTPTS[b]; \
[a][b]concat=n=2:v=0:a=1[out]" \
-map "[out]" -c:a libmp3lame -b:a 320k output.mp3
This trims the first 300 seconds (5:00) and everything after 315 seconds (5:15), then concatenates them. Note that this requires re-encoding because the audio data is being modified.
FFmpeg accepts several time formats:
| Format | Example | Description |
|---|---|---|
| HH:MM:SS | 01:23:45 | Hours, minutes, seconds |
| HH:MM:SS.mmm | 01:23:45.500 | With milliseconds |
| Seconds | 5025.5 | Total seconds (decimal) |
| Duration | 60 | Duration in seconds (with -t flag) |
-c copy unless you need to modify the audio (fades, volume, format change).-map_metadata 0 to carry over metadata from the input file.-y) overwrites existing files without warning. Never use the same filename for input and output.Whether you are cutting ringtones, editing podcasts, extracting samples, or trimming voice recordings, the key is to preserve quality by avoiding unnecessary re-encoding. Use -c copy for lossless cuts, add short fades to prevent click artifacts, and choose the right output format for your distribution needs. For batch operations, combine trimming with our batch processing guide for maximum efficiency.
Sarah Chen
Technical writer specializing in multimedia formats and digital workflows. Covers file conversion, video encoding, and document processing.