# Audio Noise Remover (`parseforge/noise-remover`) Actor

Remove background noise from audio files with support for multiple formats. Upload any audio file (MP3, WAV, M4A, FLAC, OGG, AAC) and get a clean, professional-quality audio file. Perfect for podcasters, content creators, and anyone who needs to clean up audio recordings.

- **URL**: https://apify.com/parseforge/noise-remover.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Videos, Other, Social media
- **Stats:** 31 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🔇 Noise Remover

> 🚀 **Remove background noise from audio files in seconds.** Upload any audio file and get a clean version with configurable noise reduction. Supports MP3, WAV, and more. No coding, no audio engineering skills required.

> 🕒 **Last updated:** 2026-04-23 · **🎧 Multi-format support** · **🎚️ Adjustable reduction** · **📦 Batch processing** · **🚫 No software** needed

The **Noise Remover** cleans background noise from audio files using AI. Upload an audio file URL, set the noise reduction level, and get back a clean version in your chosen output format. Supports MP3, WAV, and other common audio formats. Option to preserve original audio quality during processing.

Built for podcasters, content creators, journalists, meeting teams, and anyone who needs clean audio without professional audio editing software.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Podcasters, content creators, journalists, meeting teams, video editors, voiceover artists | Podcast cleanup, interview noise removal, meeting audio cleanup, voiceover preparation, video audio enhancement |

---

### 📋 What the Noise Remover does

Audio cleanup with adjustable settings:

- 🎧 **Audio input.** Upload any audio file URL (MP3, WAV, M4A, etc.).
- 🎚️ **Noise reduction level.** Adjustable intensity for mild to heavy noise.
- 📦 **Output format.** Choose your preferred output format.
- 🔊 **Quality preservation.** Option to maintain original audio quality.

Each output includes the cleaned audio file URL, original file reference, processing time, and noise reduction settings applied.

> 💡 **Why it matters:** professional noise removal in Audacity or Adobe Audition takes time and skill. This Actor processes audio files in seconds with one-click noise reduction, making clean audio accessible to anyone.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to clean up noisy audio._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>audioFileUrl</td><td>string</td><td>""</td><td>URL to the audio file to clean.</td></tr>
<tr><td>outputFormat</td><td>string</td><td>"mp3"</td><td>Output format: mp3, wav, etc.</td></tr>
<tr><td>noiseReductionLevel</td><td>string</td><td>"medium"</td><td>Reduction intensity: low, medium, high.</td></tr>
<tr><td>preserveOriginalQuality</td><td>boolean</td><td>true</td><td>Maintain original audio quality.</td></tr>
</tbody>
</table>

**Example: clean up a podcast recording.**

```json
{
    "audioFileUrl": "https://example.com/podcast-raw.mp3",
    "noiseReductionLevel": "medium",
    "outputFormat": "mp3"
}
````

**Example: heavy noise removal for an interview.**

```json
{
    "audioFileUrl": "https://example.com/interview.wav",
    "noiseReductionLevel": "high",
    "preserveOriginalQuality": true
}
```

> ⚠️ **Good to Know:** higher noise reduction levels remove more background noise but may slightly affect voice clarity. Start with "medium" and adjust based on results.

***

### 📊 Output

Each processed file is saved to the Key-Value Store. The dataset contains metadata.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🎧 originalAudioUrl | string | `"https://example.com/podcast-raw.mp3"` |
| 🔇 cleanedAudioUrl | string | `"https://api.apify.com/v2/key-value-stores/..."` |
| 📦 outputFormat | string | `"mp3"` |
| 🎚️ noiseReductionLevel | string | `"medium"` |
| 🔊 preservedQuality | boolean | true |
| ⏱️ processingTimeSeconds | number | `15.2` |
| 🕒 processedAt | ISO 8601 | `"2026-04-16T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🎙️ Podcast with medium noise removal</strong></summary>

```json
{
    "originalAudioUrl": "https://example.com/podcast-raw.mp3",
    "cleanedAudioUrl": "https://api.apify.com/v2/key-value-stores/abc/records/podcast-clean.mp3",
    "outputFormat": "mp3",
    "noiseReductionLevel": "medium",
    "preservedQuality": true,
    "processingTimeSeconds": 15.2,
    "processedAt": "2026-04-16T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🎤 Interview with heavy noise removal</strong></summary>

```json
{
    "originalAudioUrl": "https://example.com/noisy-interview.wav",
    "cleanedAudioUrl": "https://api.apify.com/v2/key-value-stores/abc/records/interview-clean.wav",
    "outputFormat": "wav",
    "noiseReductionLevel": "high",
    "preservedQuality": true,
    "processingTimeSeconds": 22.8,
    "processedAt": "2026-04-16T00:00:05.000Z"
}
```

</details>

<details>
<summary><strong>📱 Short voice memo with light cleanup</strong></summary>

```json
{
    "originalAudioUrl": "https://example.com/memo.m4a",
    "cleanedAudioUrl": "https://api.apify.com/v2/key-value-stores/abc/records/memo-clean.mp3",
    "outputFormat": "mp3",
    "noiseReductionLevel": "low",
    "preservedQuality": false,
    "processingTimeSeconds": 4.1,
    "processedAt": "2026-04-16T00:00:10.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎚️ | **Adjustable reduction.** Low, medium, high noise removal intensity. |
| 🎧 | **Multi-format.** MP3, WAV, M4A, and more. |
| 🔊 | **Quality preservation.** Option to maintain original audio quality. |
| 📦 | **Batch capable.** Process multiple files by running multiple times. |
| ⚡ | **Fast.** Most files process in under 30 seconds. |
| 🚫 | **No audio software.** No Audacity, no Adobe Audition, no plugins. |

> 📊 Background noise is the #1 quality issue in podcasts, interviews, and meeting recordings. One-click noise removal makes professional audio quality accessible to anyone.

***

### 📈 How it compares to alternatives

| Approach | Cost | Quality control | Speed | Batch | Setup |
|---|---|---|---|---|---|
| **⭐ Noise Remover** *(this Actor)* | $5 free credit, then pay-per-use | 3 levels | Seconds | Via API | ⚡ 2 min |
| Audacity (manual) | Free | Full control | Minutes per file | Semi | ⏳ Learning curve |
| Adobe Audition | $22/month | Full control | Minutes per file | Yes | ⏳ Hours of learning |
| Online noise removers | Free-$10/month | Limited | Varies | No | 🕒 Per file |

Pick this Actor when you want one-click noise removal without audio editing software.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Noise Remover page on the Apify Store.
3. 🎯 **Set input.** Upload an audio file URL, pick noise reduction level and output format.
4. 🚀 **Run it.** Click **Start** and let the Actor clean your audio.
5. 📥 **Download.** Grab your cleaned audio from the **Key-Value Store**.

> ⏱️ Total time from signup to clean audio: **2-3 minutes.** No audio skills required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎙️ Podcasters & Content Creators

- Clean up podcast recordings before publishing
- Remove background hum from interview audio
- Prepare voiceover tracks for video
- Process episode backlogs in batch

</td>
<td width="50%" valign="top">

#### 🏢 Business & Education

- Clean meeting recordings for transcription
- Remove noise from training videos
- Prepare presentation audio for sharing
- Process lecture recordings for archives

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Journalism & Media

- Clean field recordings with wind or crowd noise
- Prepare interview audio for broadcast
- Process multiple source files per story
- Improve audio for video packages

</td>
<td width="50%" valign="top">

#### 🎵 Music & Audio Production

- Clean demo recordings
- Remove room noise from vocal takes
- Prepare stems for mixing
- Process reference tracks

</td>
</tr>
</table>

***

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Audio%20Noise%20Remover%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Audio%20Noise%20Remover%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Audio%20Noise%20Remover%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Audio%20Noise%20Remover%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

### ❓ Frequently Asked Questions

<details>
<summary><b>💳 Do I need a paid Apify plan to run this actor?</b></summary>

No. You can start right now on the free Apify plan, which includes **$5 in free monthly credit**. That is enough to run this actor several times and explore the output before committing to anything. Paid plans unlock higher limits, more concurrent runs, and larger datasets. [Create a free Apify account here](https://console.apify.com/sign-up?fpr=vmoqkp) to get started.

</details>

<details>
<summary><b>🚨 What happens if my run fails or returns no results?</b></summary>

Failed runs are not charged. If the source site changes, proxies get rate-limited, or a specific input matches nothing, re-run the actor or open our [contact form](https://tally.so/r/BzdKgA) and we will investigate. You can also check the run log in the Apify console to see why the run stopped.

</details>

<details>
<summary><b>📏 How many items can I scrape per run?</b></summary>

Free users are limited to **10 items per run** so you can preview the output and confirm the actor works for your use case. Paid users can raise maxItems up to **1,000,000** per run. [Upgrade here](https://console.apify.com/sign-up?fpr=vmoqkp) if you need full scale.

</details>

<details>
<summary><b>🕒 How fresh is the data?</b></summary>

Every run fetches live data at the moment of execution. There is no cache or delay: the records you get reflect what the source returned at that moment. Schedule the actor to maintain a rolling snapshot of the data you need.

</details>

<details>
<summary><b>🧑‍💻 Can I call this actor from my own code?</b></summary>

Yes. Apify exposes every actor as a REST endpoint and ships first-class SDKs for [Node.js](https://docs.apify.com/sdk/js) and [Python](https://docs.apify.com/sdk/python). You can start a run, read the dataset, and handle webhooks from your own app in a few lines. All you need is your Apify API token.

</details>

<details>
<summary><b>📤 How do I export the data?</b></summary>

Every Apify dataset can be downloaded in one click from the console as CSV, JSON, JSONL, Excel, HTML, XML, or RSS. You can also pull results programmatically via the [Apify API](https://docs.apify.com/api/v2) or stream them into BigQuery, S3, and other destinations through built-in integrations.

</details>

<details>
<summary><b>📅 Can I schedule the actor to run automatically?</b></summary>

Yes. Use the Apify scheduler to run the actor on any cadence, from hourly to monthly. Results are saved to your dataset and can be delivered to webhooks, email, Slack, cloud storage, or automation tools such as Zapier and Make.

***

</details>

### 🔌 Automating Noise Remover

Control the remover programmatically for batch processing and pipeline integrations:

- 🟢 **Node.js.** Install the apify-client NPM package.
- 🐍 **Python.** Use the apify-client PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

### 🔌 Integrate with any app

Noise Remover connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get notifications when done
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe results into your pipeline
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export to Drive

***

### 🔗 Recommended Actors

- [**🎤 Audio Transcriber**](https://apify.com/parseforge/audio-transcriber) - Speech to text conversion
- [**🎬 YouTube Scraper**](https://apify.com/parseforge/youtube-scraper) - Video data and channel stats
- [**💬 YouTube Comments Scraper**](https://apify.com/parseforge/youtube-comments-scraper) - Video comments
- [**🎨 Auto Video Thumbnail Generator**](https://apify.com/parseforge/auto-video-thumbnail-generator) - Video thumbnails
- [**🖼️ Image Converter API**](https://apify.com/parseforge/image-converter-api) - Format conversion

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more audio and media tools.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new tool, propose a custom project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent audio processing tool. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `audioFileUrl` (type: `array`):

Upload your audio file here. Supports MP3, WAV, M4A, FLAC, OGG, AAC, and other common audio formats. The file will be processed to remove background noise and improve audio quality.

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

Choose the format for the processed audio file. The audio will be converted to this format after noise removal.

## `noiseReductionLevel` (type: `string`):

Select how aggressive the noise reduction should be. Low: Subtle noise removal, preserves more original audio. Medium: Balanced noise reduction (recommended). High: Maximum noise removal, may affect audio quality slightly.

## `preserveOriginalQuality` (type: `boolean`):

When enabled, uses higher bitrate (192 kbps) to preserve audio quality. When disabled, uses standard bitrate (128 kbps) for smaller file size.

## Actor input object example

```json
{
  "audioFileUrl": [
    "https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3"
  ],
  "outputFormat": "mp3",
  "noiseReductionLevel": "medium",
  "preserveOriginalQuality": true
}
```

# Actor output Schema

## `overview` (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 = {
    "audioFileUrl": [
        "https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3"
    ],
    "outputFormat": "mp3",
    "noiseReductionLevel": "medium",
    "preserveOriginalQuality": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "audioFileUrl": ["https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3"],
    "outputFormat": "mp3",
    "noiseReductionLevel": "medium",
    "preserveOriginalQuality": True,
}

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

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

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

```

## CLI example

```bash
echo '{
  "audioFileUrl": [
    "https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3"
  ],
  "outputFormat": "mp3",
  "noiseReductionLevel": "medium",
  "preserveOriginalQuality": true
}' |
apify call parseforge/noise-remover --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/noise-remover",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Audio Noise Remover",
        "description": "Remove background noise from audio files with support for multiple formats. Upload any audio file (MP3, WAV, M4A, FLAC, OGG, AAC) and get a clean, professional-quality audio file. Perfect for podcasters, content creators, and anyone who needs to clean up audio recordings.",
        "version": "1.0",
        "x-build-id": "TZLQEtWZZz7n5fJnm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~noise-remover/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-noise-remover",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~noise-remover/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-noise-remover",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~noise-remover/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-noise-remover",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "audioFileUrl"
                ],
                "properties": {
                    "audioFileUrl": {
                        "title": "Audio File Upload",
                        "type": "array",
                        "description": "Upload your audio file here. Supports MP3, WAV, M4A, FLAC, OGG, AAC, and other common audio formats. The file will be processed to remove background noise and improve audio quality."
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "mp3",
                            "wav",
                            "m4a",
                            "flac",
                            "ogg",
                            "aac"
                        ],
                        "type": "string",
                        "description": "Choose the format for the processed audio file. The audio will be converted to this format after noise removal.",
                        "default": "mp3"
                    },
                    "noiseReductionLevel": {
                        "title": "Noise Reduction Level",
                        "enum": [
                            "low",
                            "medium",
                            "high"
                        ],
                        "type": "string",
                        "description": "Select how aggressive the noise reduction should be. Low: Subtle noise removal, preserves more original audio. Medium: Balanced noise reduction (recommended). High: Maximum noise removal, may affect audio quality slightly.",
                        "default": "medium"
                    },
                    "preserveOriginalQuality": {
                        "title": "Preserve Original Quality",
                        "type": "boolean",
                        "description": "When enabled, uses higher bitrate (192 kbps) to preserve audio quality. When disabled, uses standard bitrate (128 kbps) for smaller file size.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
