# Audio Noise Remover API: Clean Speech in MP3, WAV, MP4 (`magnova/audio-noise-remover`) Actor

Remove background noise, hiss and room echo from speech in MP3, WAV, M4A or MP4 URLs with the DeepFilterNet AI model. Clean file download, loudness-normalised, with before/after noise floor and LUFS. $0.02 per audio minute.

- **URL**: https://apify.com/magnova/audio-noise-remover.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** AI, Videos, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 audio minute cleaneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Audio Noise Remover API: clean speech in MP3, WAV and MP4

**Audio Noise Remover takes links to voice recordings and returns a cleaned file with the background noise taken out.** It runs the open-source DeepFilterNet3 speech-enhancement model, evens out the loudness, and hands back a download link plus before/after measurements (noise floor and LUFS) so you can see what changed. Price: **$0.02 per audio minute**, no start fee, failed files are never charged.

Use it to remove hiss, fans, air conditioning, traffic, keyboard clatter, hum and light room echo from podcasts, interviews, voice memos, lectures, calls, screen recordings and video narration, with no API key, no account on another service and nothing to install.

### What you get for each file

| Field | Meaning |
|---|---|
| `outputUrl` | Download link to the cleaned MP3, M4A, WAV, FLAC or Opus (or MP4/MKV with the cleaned audio swapped into your video) |
| `noiseFloorBeforeDb`, `noiseFloorAfterDb`, `noiseReductionDb` | Level of the quietest passages before and after cleaning (dBFS RMS trough). Lower is quieter |
| `loudnessBeforeLufs`, `loudnessAfterLufs`, `truePeakAfterDb` | Integrated loudness and true peak, so every episode can land at the same level |
| `durationSecs`, `processedSecs`, `billedMinutes` | What was cleaned and what you were charged for |
| `status`, `error` | `ok`, `error` or `skipped`, with a plain-English reason |

The full table of results is in the dataset (Overview view). Cleaned files sit in the run's key-value store and the links open without a token.

### Quick start

1. Click **Try for free** and paste one or more direct file URLs into **Audio or video file URLs**.
2. Leave the defaults (maximum reduction, normalise to -16 LUFS, MP3) or change them.
3. Start the run. Download the cleaned files from the `outputUrl` column.

#### Use with AI agents / MCP

The Actor has one required input, `sources`, and a working example, so an agent can call it zero-shot.

```json
{
  "sources": ["https://upload.wikimedia.org/wikipedia/commons/a/a5/Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1.opus"],
  "reduction": "maximum",
  "targetLufs": -16,
  "outputFormat": "mp3"
}
```

Sample output (shortened):

```json
{
  "sourceUrl": "https://upload.wikimedia.org/wikipedia/commons/a/a5/Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1.opus",
  "status": "ok",
  "durationSecs": 67.84,
  "billedMinutes": 1,
  "outputUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1-clean.mp3?signature=...",
  "outputFormat": "mp3",
  "noiseFloorBeforeDb": -43.6,
  "noiseFloorAfterDb": -88.2,
  "noiseReductionDb": 44.6,
  "loudnessBeforeLufs": -13.6,
  "loudnessAfterLufs": -16.3,
  "truePeakAfterDb": -3.4
}
```

### Settings

- **Noise reduction strength**: `maximum` removes as much as the model can. `strong` (up to 35 dB), `medium` (20 dB) and `gentle` (12 dB) cap the reduction so some natural room tone stays.
- **Extra residual-noise filter**: DeepFilterNet's post-filter for very noisy recordings.
- **Rumble filter (Hz)**: a high-pass filter, 80 Hz suits most voices, applied before cleaning.
- **Normalise loudness / Target loudness**: -16 LUFS for podcasts, -14 for YouTube and streaming, -23 for EBU R128 broadcast. The result is checked after encoding and the gain is corrected if it landed more than 0.7 LU off target. A limiter keeps true peaks near -1.5 dBTP.
- **Output format and bitrate**: MP3, M4A (AAC), WAV (48 kHz), FLAC or Opus.
- **Keep the video track**: for video sources the picture is copied untouched and only the audio is replaced.
- **Max minutes per file** and **Max file size**: spending guards. You pay only for minutes actually cleaned.

### How it works

Each file is downloaded, probed with ffprobe, then cut into six-minute pieces with 1.5 seconds of overlap on each side. Every piece goes through DeepFilterNet3 at 48 kHz, the overlap is trimmed, and the pieces are joined, so memory stays flat for hour-long recordings. The result is measured, gain-adjusted and encoded with ffmpeg. With 8 GB of memory two pieces run in parallel.

Speed depends on the memory you give the run: roughly 3x real time at the default 4 GB and around 7x on long files at 8 GB, so a one-hour podcast takes about 20 minutes at the default. Cost per audio minute stays about the same either way, so choose more memory when you want results sooner.

### How much does it cost to clean audio?

**$0.02 per audio minute** at the Free and Bronze tiers, $0.017 for Silver and $0.014 for Gold. Minutes are rounded up per file. A 30-minute podcast episode costs about $0.60 on the Free tier; a one-hour interview about $1.20. That compares with roughly $1.40 per hour at Auphonic, $0.60 to $2.20 per hour at Cleanvoice and about $7 per hour for ElevenLabs Voice Isolator, with nothing to subscribe to here. Errors, unsupported links and files without audio cost nothing. Set a maximum charge on the run and the Actor stops cleanly when it is reached.

### Audio noise remover API

Call it from code with the Apify API or client libraries, schedule it, or plug it into n8n, Make or Zapier. Typical pipeline: download recording, run Audio Noise Remover, then send `outputUrl` to a transcription Actor such as Audio & Podcast Transcriber, since cleaner audio usually improves transcription accuracy.

### Best results and limits

- It is trained for **speech**. Music and singing are not its target and may sound dull or watery. Use `gentle` if you must process mixed material.
- It removes steady and non-steady background noise and some reverb. It does not remove other voices, so a second speaker in the background stays.
- Very low-bitrate or heavily clipped sources keep their compression artefacts.
- Files must be direct links to audio or video. Pages from YouTube, Spotify, SoundCloud, TikTok, Instagram and similar sites are rejected, because downloading from them breaks their terms.
- Output is 48 kHz. Stereo stays stereo; mono stays mono.

### Is it legal?

Yes, by design. The Actor performs pure computation on files you point it to: it does not scrape websites, log in anywhere or bypass any protection. DeepFilterNet is published under the MIT and Apache-2.0 licences, which permit commercial use. You are responsible for having the right to process the recordings you submit, and the Actor refuses streaming and social-media page URLs for that reason. The model runs inside the Actor, so your audio is not sent to any third-party service, and results are stored only in your own run storage.

### FAQ

**How do I remove background noise from an MP3?** Paste the MP3 URL into Audio or video file URLs and run. The cleaned MP3 is in `outputUrl`.

**Can it clean the audio of a video?** Yes. With Keep the video track on, you get the same video (picture copied, not re-encoded) with cleaned audio.

**Does it work in languages other than English?** The model is language-independent because it works on the sound, not the words, so it handles any spoken language.

**Will it change how the voice sounds?** At `maximum` strength you get the cleanest result; at `medium` or `gentle` more of the original room character remains.

**What is LUFS?** A loudness measure used by podcast and streaming platforms. Normalising to -16 LUFS makes episodes sound equally loud.

**Alternatives?** Adobe Podcast Enhance, Auphonic, Cleanvoice and ElevenLabs Voice Isolator are polished editors or priced per hour. This Actor is for batch and API use with open pricing and no sign-ups.

### Support

Found a file that does not work or want another output option? Open an issue on the Actor page and include the run link.

# Actor input Schema

## `sources` (type: `array`):

Direct links to speech recordings you own or have rights to: MP3, WAV, M4A/AAC, FLAC, OGG, OPUS, MP4, MOV or WEBM (podcasts, interviews, voice memos, calls, lectures, screen recordings). Each file becomes one cleaned file. YouTube, Spotify, SoundCloud, TikTok, Instagram and other streaming or social page URLs are rejected for free. Example: https://upload.wikimedia.org/wikipedia/commons/a/a5/Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1.opus

## `reduction` (type: `string`):

How much background noise may be removed. maximum = no limit (best for hiss, hum, fans, traffic, keyboard, room noise); strong = up to 35 dB; medium = up to 20 dB (keeps some natural room tone); gentle = up to 12 dB (barely audible processing). Example: medium for interviews that should still sound like a room.

## `postFilter` (type: `boolean`):

Adds DeepFilterNet's post-filter, which suppresses faint leftover noise in very noisy recordings at the cost of slightly more processed sound. Leave off for normal recordings.

## `highPassHz` (type: `integer`):

Optional: cut everything below this frequency before cleaning, to remove desk thumps, wind and mains rumble. 80 Hz suits most voices. Leave empty for no filter. Example: 80.

## `normalizeLoudness` (type: `boolean`):

Two-pass EBU R128 loudness normalisation of the cleaned audio so episodes sound equally loud. Turn off to keep the original level.

## `targetLufs` (type: `number`):

Integrated loudness target when normalisation is on. -16 = podcasts (Apple, Spotify mono/stereo), -14 = YouTube and streaming, -23 = EBU R128 broadcast. Example: -16.

## `outputFormat` (type: `string`):

File type for audio-only output. mp3 (192 kbps by default) is smallest and works everywhere; m4a is AAC; wav and flac are lossless 48 kHz; opus is tiny for voice. Files with a video track follow keepVideo instead.

## `bitrateKbps` (type: `integer`):

Bitrate for mp3, m4a and opus output (ignored for wav and flac, and for opus use 64-96 for speech). Example: 128.

## `keepVideo` (type: `boolean`):

When a source is a video, return the video with the cleaned audio swapped in (video stream copied, not re-encoded, so it is fast and lossless). Turn off to get audio only in the chosen output format.

## `maxMinutesPerFile` (type: `number`):

Optional cap: clean only the first N minutes of each file (you pay only for what is cleaned). Leave empty for full files. Example: 30.

## `maxFileSizeMb` (type: `integer`):

Files larger than this are skipped with an error row (not charged). Example: 500.

## Actor input object example

```json
{
  "sources": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a5/Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1.opus"
  ],
  "reduction": "maximum",
  "postFilter": false,
  "normalizeLoudness": true,
  "targetLufs": -16,
  "outputFormat": "mp3",
  "bitrateKbps": 192,
  "keepVideo": true,
  "maxFileSizeMb": 1000
}
```

# Actor output Schema

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

No description

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

No description

## `summary` (type: `string`):

No description

# 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 = {
    "sources": [
        "https://upload.wikimedia.org/wikipedia/commons/a/a5/Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1.opus"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/audio-noise-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 = { "sources": ["https://upload.wikimedia.org/wikipedia/commons/a/a5/Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1.opus"] }

# Run the Actor and wait for it to finish
run = client.actor("magnova/audio-noise-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 '{
  "sources": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a5/Live_recording_of_interview_with_Dr_Amba_Ambaiowei_Pt_1.opus"
  ]
}' |
apify call magnova/audio-noise-remover --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/audio-noise-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/J4rqMNxjpGcgogw5v/builds/C6V4d7z0cNtPfCTF6/openapi.json