You hit record on a Zoom call because something good was about to happen: a product demo for a customer, a meetup talk, a pairing session you want to share with the team, or a webinar you promised to post afterwards.

Then you open the file. The first four minutes are "can everyone see my screen?", there's a long silence while someone finds the right tab, and the best explanation of the hour is buried in the middle between two tangents.

Zoom gives you a trim tool, and for some recordings that's enough. For most of the ones you actually want to share, it isn't. Here are seven ways to edit a Zoom recording, from the free button you already have to an AI editor that does the slow passes for you.

Why editing a Zoom recording is harder than it looks

A Zoom recording isn't a scripted video. Nobody planned the pauses, people talk over each other, and the useful parts rarely start at 0:00. That gives you three kinds of edits:

1. Trim the ends. Cut the waiting room chat at the start and the goodbyes at the end.
2. Cut the middle. Remove a tangent, a broken demo, a private aside, or a stretch where someone shared the wrong screen.
3. Tighten the talk. Close long pauses, "ums" and false starts so a 50-minute call plays like a 35-minute one.

Zoom's built-in tool handles the first. Everything below handles the second, and only some tools handle the third without you scrubbing through the whole hour.

Quick picks

• Best overall: MirrorCut, AI video editor (mirrorcut.ai), for an AI first cut you review change by change
• Best free option for trimming the ends: Zoom's cloud recording trim
• Best for editing through the transcript: Descript
• Best free browser editor: Clipchamp
• Best for quick silence removal in a browser: Kapwing
• Best for polished tutorials and training videos: Camtasia
• Best for scripting it yourself: ffmpeg

The 7 best tools to edit Zoom recordings

1. MirrorCut, AI video editor (mirrorcut.ai): best overall

MirrorCut is my top pick when the recording is worth sharing but you don't want to spend an evening scrubbing through it. Download the MP4 from Zoom, upload it (MP4, MOV, MKV and WebM all work, and hour-long files are fine), and tell its agent what you want in plain words: "remove the dead air, filler words and retakes", or "cut the false start at the beginning and the tangent about pricing".

The part that matters for a call recording is how the cuts come back. Every removal lands on a real timeline, outlined and explained in one line, such as "Removing a 0.6 s pause at 0:54". You keep it, revert it or adjust it by hand, so a meaningful pause in a customer's answer doesn't vanish without you seeing it. Picture, sound and captions close up together, so nothing drifts.

You can also ask how much dead air and how many "ums" there are before anything is cut, add chapter markers at each topic change, add word-by-word captions and download them as SRT or VTT, and pull a 60-second highlight reel from the best answers. Its dead air and filler word page lists webinars and product demos among the recordings it's built for, and the full feature list shows what else you can ask for.

It works in your browser and exports MP4 up to 4K. Every account starts with 7 days of the Creator plan free (a card is required), then plans are $10, $30 or $60 a month, and every plan has every feature. See MirrorCut pricing.

Best for: demos, webinars, meetup talks and interviews you want to publish, not just archive.

2. Zoom's cloud recording trim: best free option for trimming the ends

If you recorded to the cloud, Zoom's web portal can trim the recording without downloading anything. Open the recording, click the scissors icon, drag the sliders to the start and end you want, and you can add more trim sections to keep. Trimming overwrites the shared version, along with its audio and transcript files, but you can restore the original later.

There are limits. Zoom's own article says it can take about 2 hours to trim a long recording, you can trim each recording only 5 times every 12 hours, and it doesn't work in mobile browsers. It's a trim tool, not an editor: no captions you can style, no pause removal, no cleanup.

Best for: chopping the waiting room and goodbyes off a recording you'll share as a Zoom link.

3. Descript: best for editing through the transcript

Descript lets you edit audio and video by editing the transcript, so cutting a tangent means deleting a paragraph. Its pricing page lists Remove Filler Words, Remove Retakes, Studio Sound and Underlord, its AI co-editor. There's a free plan, and the Hobbyist plan exports 1080p without a watermark.

Best for: people who think in text and want to read the call rather than watch it.

4. Clipchamp: best free browser editor

Clipchamp is Microsoft's browser video editor, and "how to edit a Zoom recording in Clipchamp" is a common search for a reason. Its pricing page says the free plan includes basic tools like trim, crop and resize, plus AI subtitles and silence removal, with watermark-free exports up to 1080p. Premium features such as 4K export come with Microsoft 365 Personal and Family.

Best for: a free, no-install edit with a few cuts and subtitles.

5. Kapwing: best for quick silence removal in a browser

Kapwing is an online editor with a feature called Smart Cut, which its pricing page describes as removing silences from your video automatically. The free plan exports at 720p with a Kapwing watermark, and Kapwing says it doesn't currently offer a free trial of its paid plans.

Best for: a fast silence pass on a short clip when a watermark is fine.

6. Camtasia: best for polished tutorials and training videos

TechSmith's Camtasia Editor is a desktop editor long used for screen-recorded training. Its own tutorial on editing Zoom recordings shows importing cloud recordings you hosted straight from Zoom (File > Import > Zoom), trimming the start and end, removing sections with text-based editing, removing ums and ahs, adjusting audio levels and generating captions.

Best for: turning a recorded session into a course module or onboarding video.

7. ffmpeg: best for scripting it yourself

If you'd rather stay in a terminal, ffmpeg can find the silences and cut the ends for you. Its silencedetect filter prints where every quiet stretch starts and ends:

# list every silence longer than 2 seconds
ffmpeg -i zoom.mp4 -af silencedetect=n=-35dB:d=2 -f null -

# keep only the part between 3:10 and 52:40
ffmpeg -ss 00:03:10 -to 00:52:40 -i zoom.mp4 -c copy trimmed.mp4

-c copy is fast because it doesn't re-encode, but it cuts on keyframes, so the start can land a moment off. Drop -c copy if you need a frame-accurate cut. Removing many gaps from the middle means building a filter or a concat list, which is where a script gets long.

Best for: batch-trimming a folder of meeting recordings, or anyone who wants full control and no account.

A simple workflow for any Zoom recording

1. Download the right file. If you recorded to the cloud, download the MP4 (Zoom offers separate views such as shared screen with speaker; pick the one you want people to watch).
2. Do the big cuts first. Trim the start and end, then remove whole sections: private asides, broken demos, the wrong screen.
3. Then the small cuts. Close long pauses, filler words and false starts. This is the slow pass, and the one AI tools handle best.
4. Add captions. Many people watch with the sound off, and captions make a demo easier to follow.
5. Add chapters for anything long. A webinar with chapters is far easier to skim than an hour-long block.
6. Export once, share everywhere. One MP4 for YouTube or your docs, plus a short highlight for social.

The bottom line

The best way to edit a Zoom recording depends on how far you need to go. If you only need to trim the ends, Zoom's own tool is free and already there. If you want to script it, ffmpeg will do it. But if the recording is a demo, a webinar or a talk you want people to actually watch, the slow part is the pauses, the false starts and the tangents in the middle, and that's where MirrorCut earns its place at the top: it does those passes for you and shows you every cut before you keep it.

Comparing more editors? Here's a longer MirrorCut list of Descript alternatives.

Editing that by hand is where most developer screencasts die. You record, you dread the edit, and the video never ships.

Here are seven tools that make the edit fast, from AI editors to a 40-line ffmpeg script, and a workflow that works with any of them. None of it needs Premiere.

What matters when editing a screen recording

• Silence and retakes removed automatically. That's most of the waste.
• Cutting by meaning, not just volume. Filler words and repeated takes aren't silent.
• Reviewable cuts. An automatic cut that hides your command output is worse than no cut. You want to see each cut and undo just that one.
• Captions as files (SRT/VTT), not only burned in.
• No face needed. Most screencasts are just the screen and your voice.

1. MirrorCut: an AI first cut you can review cut by cut (our tool)

MirrorCut is an AI agent that edits your recordings in the browser. It works on screen recordings with only a voice-over and no face on camera. You upload the recording and the agent makes the first cut: it removes dead air, filler words, retakes and false starts.

• Review and undo: every AI change is outlined on the timeline with a one-line reason and its own Accept and Revert. If it cut the pause where your test output appears, you revert that one cut and keep the rest. AI edits and your own edits share one undo history.
• Captions and outputs: auto captions in 48 styles that stay in sync after cuts; export MP4 up to 4K, plus SRT and VTT. Long video to Shorts is a built-in step.
• Price: Creator $10/month, Pro $30, Studio $60. Every plan has every feature (pricing).
• Not the right pick if: you want zoom and cursor effects applied while you record (see #3 and #4), you finish in an NLE (no NLE project export today), or you'd rather pay nothing and script it (#6, #7).
• Best for: developers who want the first 80% done for them and a quick review of the rest.

2. Descript: edit the recording like a doc

Descript turns your recording into a transcript you edit like text. Its chat co-editor Underlord (labelled beta) handles Remove Filler Words, Remove Retakes and captions.

• Review and undo: Underlord creates a checkpoint you can revert to; per Descript's help docs, checkpoints last only for the current session (help).
• Hand-off: timeline export to Premiere, Final Cut Pro and others.
• Price: Free (60 media minutes a month, 720p export); Hobbyist $24/month or $16 billed annually (pricing).
• Best for: transcript-first editing, and anyone who finishes in an NLE.

3. Camtasia: the classic screen-recording editor

Camtasia is TechSmith's desktop recorder and editor for Windows and macOS.

• What it does: text-based editing and filler word and hesitation removal (via Audiate), captions you can export in subtitle formats, AI noise removal, and automatic cursor effects (Screentelligence).
• Price: a free editor that watermarks exports; paid plans are Essentials, Create and Pro (see TechSmith's pricing page for current prices).
• Best for: teams making polished training and software tutorials on the desktop.

4. Screen Studio: good-looking recordings by default (macOS)

Screen Studio is a macOS recorder that makes recordings look edited as you capture them.

• What it does: automatic zooms and cursor smoothing, editing by transcript, removing filler words and pauses, captions with SRT export, and MP4 up to 4K in 16:9, 1:1 or 9:16. Processing is local.
• Price: $29/month, every feature on every plan.
• Best for: Mac users making product demos where zoom and cursor polish matter.

5. Loom (Business + AI): quick async videos

Loom is built for quick, shareable screen recordings for your team.

• What it does: on the Business + AI plan, filler word removal, silence removal and editing by transcript.
• Price: Starter is free (25 videos, 5-minute recordings, 720p). Business is $18 and Business + AI $24, per user.
• Best for: internal walkthroughs and PR demos rather than public tutorials.

6. auto-editor: an open-source CLI first pass

auto-editor is a command-line app that cuts out "dead space", typically silence, as a first pass: auto-editor path/to/your/video.mp4.

• What it does: cuts by audio loudness by default, can cut by motion instead (or both), and --margin keeps a little padding around each cut so the edit feels natural.
• Price: free and open source.
• Best for: developers who want a mature, scriptable silence cutter without writing one.

7. A 40-line ffmpeg script you own

If you'd rather see every line, ffmpeg's silencedetect filter reports where the quiet stretches are. This script turns that report into "keep" segments and renders a new file with the long pauses removed. I tested it on ffmpeg 7.1 with Python 3.

#!/usr/bin/env python3
"""Cut long pauses out of a screen recording with ffmpeg.
Usage: python3 trim_silence.py input.mp4 output.mp4
"""
import re, subprocess, sys

src, out = sys.argv[1], sys.argv[2]
NOISE = "-35dB"   # what counts as silence
MIN_GAP = 0.8     # only cut pauses longer than this (seconds)
PAD = 0.15        # keep a little air on each side of a cut

# 1. Ask ffmpeg where the silences are.
log = subprocess.run(
    ["ffmpeg", "-hide_banner", "-i", src,
     "-af", f"silencedetect=noise={NOISE}:d={MIN_GAP}", "-f", "null", "-"],
    capture_output=True, text=True).stderr
starts = [float(x) for x in re.findall(r"silence_start: ([\d.]+)", log)]
ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", log)]
dur = float(subprocess.run(
    ["ffprobe", "-v", "error", "-show_entries", "format=duration",
     "-of", "csv=p=0", src], capture_output=True, text=True).stdout)

# 2. Turn silences into the segments we keep.
keep, cursor = [], 0.0
for s, e in zip(starts, ends + [dur] * (len(starts) - len(ends))):
    if s - cursor > 0:
        keep.append((cursor, min(s + PAD, dur)))
    cursor = max(e - PAD, 0.0)
if dur - cursor > 0.05:
    keep.append((cursor, dur))

# 3. Keep only those segments, video and audio together.
expr = "+".join(f"between(t,{a:.3f},{b:.3f})" for a, b in keep)
subprocess.run(
    ["ffmpeg", "-y", "-hide_banner", "-loglevel", "error", "-i", src,
     "-vf", f"select='{expr}',setpts=N/FRAME_RATE/TB",
     "-af", f"aselect='{expr}',asetpts=N/SR/TB", out], check=True)
print(f"kept {len(keep)} segments, {sum(b - a for a, b in keep):.1f}s of {dur:.1f}s")

On a test file with 11 seconds of audio containing two gaps (2 s and 3 s), it printed kept 3 segments, 6.6s of 11.0s. That's exactly the two pauses removed, with a little padding left in.

Tuning tips:

• NOISE: if it cuts your quiet words, lower it (for example -45dB). If it misses pauses because of fan noise, raise it (-30dB).
• MIN_GAP: for tutorials, 0.8–1.2 s feels natural. Lower values make it choppy, which suits Shorts, not lessons.
• PAD: 0.1–0.2 s stops words from getting clipped.

What the script can't do: it doesn't understand meaning. It will cut the silence while a command's output scrolls past, and that's often the moment you want viewers to see. It also can't spot retakes or filler words like "um", because those aren't silent.

• Price: free.
• Best for: learning how silence cutting works, or dropping it into your own pipeline.

Side-by-side

*Checked Oct 25, 2026, from each tool's own pages.

Which one should you pick?

• You want an AI first cut and a fast review, in the browser: MirrorCut.
• You finish in Premiere or Final Cut: Descript.
• You make polished training videos on Windows or Mac: Camtasia.
• You're on a Mac and want zooms and cursor polish while you record: Screen Studio.
• It's an internal walkthrough, not a public tutorial: Loom.
• You want free and scriptable: auto-editor, or the ffmpeg script if you want to own every line.

A workflow that works with any of them

Record so the edit is easy

Most editing time is caused at record time. Five habits save more than any tool:

• Make the screen readable first. Font size 18–20 pt in your editor and terminal, because viewers watch on phones. Record at 1920×1080 (or a 1080p crop of a bigger screen); a 4K desktop scaled down makes code tiny. Hide notifications, bookmarks, other tabs and .env files. Blurring secrets in the edit takes far longer than closing the file.
• Use a real mic in a quiet room. Viewers forgive average video, not bad audio. Any USB mic close to your mouth beats a laptop mic across the desk, and silence detection works much better when "silence" is actually quiet.
• Script the steps, not the words. A checklist ("install, configure, first request, error handling") keeps you on track and still sounds natural.
• Pre-run anything slow. If docker build takes 3 minutes, run it before you record, or say "this takes a few minutes, I'll skip ahead" and cut it.
• Mark your retakes out loud. When you fumble, pause for two seconds and say "again" before restarting the sentence. The pause shows on a waveform and the word is searchable in a transcript.

Review only the cuts that matter

Whichever tool you use, don't rewatch the whole thing at 1x:

1. Scrub the cuts near code changes. Check two seconds either side for a cut that hides a command's result, makes code "teleport" mid-typing, or removes the pause after "notice that…". Restore those.
2. Speed up, don't cut, long waits. A 4x–8x speed-up on an install keeps cause and effect visible.
3. Zoom where your eyes go, with restraint: when it explains something, not on every click.
4. Export captions as SRT or VTT as well as burned in. SRT goes to YouTube; VTT works with HTML5 <track> in your docs.

One recording, several outputs

• Docs version (16:9): the full tutorial, with chapters in the description.
• Shorts (9:16): one "aha" moment each, pulled from the edited version so they inherit the clean cuts.
• README GIF or clip: 10–20 seconds of the result, no voice needed.

A warning about vertical crops: a 9:16 frame cut from a 16:9 screen recording only shows about a third of the width. Put the key code in one area of the screen when you record, or zoom in before you crop.

Applied consistently, this turns "I'll edit it this weekend" into "I'll ship it tonight".

If you try the ffmpeg script, tell me what NOISE and MIN_GAP values worked for your mic. I'll collect them into a table. And if you'd rather have an AI do the first pass, MirrorCut is at mirrorcut.ai.

Sources (checked Oct 25, 2026)

• MirrorCut: https://www.mirrorcut.ai · https://www.mirrorcut.ai/pricing
• Descript pricing: https://www.descript.com/pricing · Underlord revert: https://help.descript.com/ai-assistant/revert
• Camtasia: https://www.techsmith.com/camtasia/
• Screen Studio: https://screen.studio
• Loom pricing: https://www.loom.com/pricing
• auto-editor: https://github.com/WyattBlue/auto-editor
• ffmpeg silencedetect: https://ffmpeg.org/ffmpeg-filters.html#silencedetect