# Silence Remover: Cut Pauses from Video & Audio (`jumblemog/silence-remover`) Actor

Automatically cut silences, pauses and dead air out of videos, podcasts, lectures and voice recordings. Jump-cut style editing with adjustable pause length and padding, frame-accurate A/V sync, and a JSON cut list for your editor. MP4, MOV, MP3, WAV and more.

- **URL**: https://apify.com/jumblemog/silence-remover.md
- **Developed by:** [Jumble Mog](https://apify.com/jumblemog) (community)
- **Categories:** Videos, For creators, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Silence Remover: Cut Pauses from Video & Audio

**Automatically remove silences, pauses and dead air** from videos, podcasts, lectures, interviews, tutorials and voice recordings. This Actor finds every pause in the speech and cuts it down, the way an editor makes jump cuts, then gives you the tightened video or audio file and a **cut list** with every timestamp. Picture and sound stay in sync, the cuts are smooth, and you choose how tight the result is. No API key, no editing software and no manual scrubbing.

![Waveform of a 40-second recording before and after: 13 pauses are cut and it becomes 30 seconds long](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/silence-remover-waveform.jpg?signature=LFDWgvP5YrGRWFjoCMmA)

Listen: [before (40 s)](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/silence-remover-before.mp3?signature=mH9zhUk4UvlzT8xpzer4) and [after (30 s)](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/silence-remover-after.mp3?signature=FSalWOX2OU8vZrWY78AR), default settings. *Sample: LibriVox recording of The Art of War (public domain).*

### What it does

- **Finds the pauses automatically**: the silence level is worked out for each file from its own background noise and speech, so it works for quiet studio recordings and noisy phone videos alike. You can also set a fixed level.
- **Cuts them cleanly**: pauses longer than your minimum (0.5 s by default) are cut, keeping a little padding (0.15 s) before and after each phrase so no word gets clipped. Every cut gets a 5 ms fade, so there are no clicks.
- **Videos stay in sync**: frames and sound are cut on the same timestamps, also for variable-frame-rate phone recordings. The result is an MP4 (H.264 + AAC) up to 1080p.
- **Audio keeps its format**: MP3 stays MP3, WAV stays WAV, at the original sample rate. Or convert to MP3, WAV, FLAC, M4A, OGG or Opus.
- **Cut list for your editor or code**: every file also gets a JSON list of kept and removed segments in seconds. Choose cut-list-only mode to skip rendering and do the edit in Premiere, DaVinci Resolve, Final Cut, CapCut or your own pipeline.
- **Clear numbers**: original and new length, seconds and percentage removed, number of pauses cut.
- **Takes files from anywhere**: direct links, Google Drive and Dropbox share links, or uploads. Files up to 2 GB and 6 hours.
- **Fair billing**: you pay per minute of input. Files that fail cost nothing.

### Who it's for

- **YouTubers, TikTokers and course creators** who want jump-cut pacing without hours of editing.
- **Podcasters** tightening interviews and solo episodes.
- **Teachers and trainers** shortening lecture and screen recordings.
- **Developers and AI agents** building automated video pipelines: cut first, then caption, translate or publish.

### How to use it

1. Paste links to videos or audio files, or upload them.
2. Keep the defaults, or make the cut tighter (shorter minimum pause, less padding) or gentler.
3. Click **Start**. Each tightened file appears in the **Output** tab with a download link and its cut list.

You can also run it through the [Apify API](https://docs.apify.com/api/v2), on a schedule, or from Make, n8n, Zapier and other integrations.

### How-to examples

Each example below is a complete input, checked with a run of the Actor on a short test file.

#### How to remove silence from a video or podcast automatically

```json
{"mediaUrls": ["https://example.com/videos/vlog-take-3.mp4"]}
```

Result: the file without its pauses in `outputUrl`, plus `removedSeconds`, `removedPercent` and `pausesRemoved`. A 9-second test file with two 1.5-second pauses came back 6.64 seconds long: "removedSeconds": 2.4, "removedPercent": 26.6, "pausesRemoved": 2. Each cut pause keeps 0.15 seconds on either side, so speech isn't clipped.

#### How to make fast jump cuts for YouTube or TikTok

```json
{"mediaUrls": ["https://example.com/videos/vlog-take-3.mp4"], "minPauseSeconds": 0.3, "paddingSeconds": 0.08}
```

Result: every pause of 0.3 seconds or more is cut down to about 0.16 seconds, for the tight talking-head style. Use `"minPauseSeconds": 1.0` to remove only long gaps.

#### How to get a cut list for Premiere, DaVinci Resolve or Final Cut

```json
{"mediaUrls": ["https://example.com/videos/interview-raw.mp4"], "output": "cutList"}
```

Result: no new file is rendered. `keepSegments` and the file at `cutListUrl` list the parts to keep and cut, in seconds of the original, such as `[[0.0, 2.15], [3.35, 5.65], [6.85, 9.04]]`. Make the edit in your own editor or script.

#### How to let an AI agent tighten recordings

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/silence-remover`. The agent sends the links in `mediaUrls` and gives the user `outputUrl`, or reads `keepSegments` when it does the edit itself.

### FAQ

**Does it need a silence level?** No. It measures each file's background noise and sets the level itself. Set `thresholdDb`, such as `-40`, to choose your own.

**Does it work on audio files?** Yes. Podcasts and voice notes in MP3, WAV, M4A, FLAC and other formats keep their format, or set `audioFormat` to convert them.

**Do the video and sound stay in sync?** Yes. Picture and sound are cut at the same points.

**Is there a watermark?** No.

**Does it work with Zapier, Make or n8n?** Yes. Call the Actor with its Apify app or an HTTP request, and pass `outputUrl` to the next step.

### Input

| Field | What it does |
| --- | --- |
| `mediaUrls` | Links to video or audio files, or Google Drive and Dropbox share links. |
| `files` | Files uploaded from your computer or picked from an Apify key-value store. |
| `minPauseSeconds` | Shortest pause that gets cut (default 0.5). Use 0.3 for fast jump cuts, 1.0 to remove only long gaps. |
| `paddingSeconds` | Part of each pause kept before and after speech (default 0.15, so cut pauses become 0.3 s). |
| `thresholdDb` | Empty (default) finds the silence level automatically; or set one, such as `-40`. |
| `output` | `media` (default): tightened file plus cut list. `cutList`: only the timestamps. |
| `audioFormat` | `same` (default) keeps audio formats and makes videos MP4; or `mp3`, `wav`, `flac`, `m4a`, `ogg`, `opus` for audio only. |
| `maxFiles` | Stop after this many files (default 100). |

Example:

```json
{
  "mediaUrls": [
    "https://example.com/videos/vlog-take-3.mp4",
    "https://drive.google.com/file/d/YOUR_FILE_ID/view?usp=sharing"
  ],
  "minPauseSeconds": 0.3,
  "paddingSeconds": 0.08
}
```

### Output

Each file becomes one dataset item. The tightened file and the cut list are saved in the run's key-value store:

```json
{
  "url": "https://example.com/videos/vlog-take-3.mp4",
  "status": "ok",
  "error": null,
  "outputUrl": "https://api.apify.com/v2/key-value-stores/<store>/records/001-vlog-take-3-no-silence.mp4?signature=...",
  "cutListUrl": "https://api.apify.com/v2/key-value-stores/<store>/records/001-vlog-take-3-cuts.json?signature=...",
  "fileName": "001-vlog-take-3-no-silence.mp4",
  "format": "mp4",
  "isVideo": true,
  "originalSeconds": 612.4,
  "newSeconds": 471.9,
  "removedSeconds": 140.5,
  "removedPercent": 22.9,
  "pausesRemoved": 187,
  "thresholdDb": -38.5,
  "minutesBilled": 11,
  "keepSegments": [[0.85, 4.2], [4.71, 9.03]],
  "processingSeconds": 95.3
}
```

The cut list file has the settings and both lists, in seconds of the original file:

```json
{
  "thresholdDb": -38.5,
  "minPauseSeconds": 0.5,
  "paddingSeconds": 0.15,
  "durationSeconds": 612.4,
  "keep": [[0.85, 4.2], [4.71, 9.03]],
  "cut": [[0.0, 0.85], [4.2, 4.71]]
}
```

A file that couldn't be downloaded or read gets `status: "failed"` and an `error` that says why, and isn't billed. Download your files within your plan's data retention period, or copy them to your own storage, because run storage expires.

### Pricing

You pay per **started minute of input**, at the prices shown on this page:

- **Minute of audio processed**: audio files, and any file in cut-list-only mode.
- **Minute of video processed**: videos that are re-rendered without their pauses (re-encoding video takes much more computing than audio).

A 10-minute video is 10 minutes; a 20-second clip is 1 minute. Files that fail are never charged. If you set a maximum cost per run, the Actor stops before a file that wouldn't fit.

### Speed

Measured on Apify at the default 4 GB of memory:

- **Audio** is fast: an 8.5-minute audiobook chapter took 7 seconds, so an hour-long podcast takes about a minute.
- **Cut lists** take about as long as audio, also for videos, because nothing is re-encoded.
- **Video** is re-encoded, which takes about as long as the video itself at 1080p: a 3-minute 1080p WebM took just under 3 minutes. Smaller videos are quicker, and giving the run more memory gives it more CPU, which speeds video up.

### Tips and limits

- Silence detection listens for **quiet**, not for words: background music or constant loud noise under the speech hides the pauses. Clean such recordings first (for example with a noise remover) or set `thresholdDb` yourself.
- Videos are re-encoded to H.264 MP4. Inputs above 1080p are rendered at 1080p (vertical videos at 1080 x 1920), and phone videos come out upright. Use the cut list to apply the edit at full resolution in your editor.
- Only the first audio track is used, and multichannel audio comes back as stereo.
- Links to YouTube, TikTok, Instagram, Facebook, X, Vimeo, SoundCloud and Spotify aren't supported, because those platforms' terms don't allow downloading. Use your own copy of the file.

### For AI agents and developers

This Actor works with the [Apify MCP server](https://mcp.apify.com), so AI agents can call it as a tool: pass `mediaUrls` and read `outputUrl` (or `keepSegments`) from each dataset item. Every item has the same documented fields, and `status` tells you whether a file succeeded. For a direct API call:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~silence-remover/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mediaUrls": ["https://example.com/talk.mp4"], "output": "cutList"}'
```

### Privacy

Files are downloaded into the run, processed there and saved only to your own Apify storage. Nothing is sent to an outside service.

### Credits

- Audio and video processing: [FFmpeg](https://ffmpeg.org) with x264.

# Actor input Schema

## `mediaUrls` (type: `array`):

Direct links to video or audio files (MP4, MOV, MKV, WebM, MP3, WAV, M4A, FLAC, OGG and more), or Google Drive and Dropbox share links. YouTube, TikTok, Instagram, Facebook, X, Vimeo, SoundCloud and Spotify links aren't supported because their terms don't allow downloading.

## `files` (type: `array`):

Upload video or audio files from your computer, or pick files you already stored in an Apify key-value store.

## `minPauseSeconds` (type: `number`):

Only pauses at least this long are cut. 0.5 s keeps the rhythm of normal speech; use 0.3 for a fast jump-cut style or 1.0 to remove only long gaps.

## `paddingSeconds` (type: `number`):

How much of each pause to keep before and after the speech, so words aren't clipped. With the default 0.15 s, every cut pause becomes 0.3 s.

## `thresholdDb` (type: `integer`):

Leave empty to find the level between background and speech automatically for each file (recommended). Or set a level, for example -40: anything quieter counts as silence.

## `output` (type: `string`):

media: the tightened video or audio file plus the cut list. cutList: only the timestamps (JSON), for editing in your own software; faster and cheaper for videos.

## `audioFormat` (type: `string`):

same: audio files keep their format and videos stay MP4 videos. Pick an audio format to get only the tightened audio, also from videos.

## `maxFiles` (type: `integer`):

Stop after this many files, so the cost of a run stays predictable.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/silence-remover-before.mp3?signature=mH9zhUk4UvlzT8xpzer4"
  ],
  "minPauseSeconds": 0.5,
  "paddingSeconds": 0.15,
  "output": "media",
  "audioFormat": "same",
  "maxFiles": 100
}
```

# Actor output Schema

## `results` (type: `string`):

One item per file: download links, original and new length, pauses removed.

## `files` (type: `string`):

The tightened files and JSON cut lists saved in the run's key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mediaUrls": [
        "https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/silence-remover-before.mp3?signature=mH9zhUk4UvlzT8xpzer4"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/silence-remover").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "mediaUrls": ["https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/silence-remover-before.mp3?signature=mH9zhUk4UvlzT8xpzer4"] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/silence-remover").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mediaUrls": [
    "https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/silence-remover-before.mp3?signature=mH9zhUk4UvlzT8xpzer4"
  ]
}' |
apify call jumblemog/silence-remover --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/silence-remover"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/VtU6ObSdO1bIqYA4J/builds/GhktMctZVGKQaCKI8/openapi.json