Name: Playmore Speech Enhancer Noise Removal API
Brand: magicapi
SKU: api-magicapi-speech-enhancer-playmore-speech-enhancer
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎙️ Speech Enhancement and Noise Removal API (Playmore Speech Enhancer)

## Overview
Speech Enhancer, published by Playmore, removes background noise from recordings of speech. You send the URL of a noisy audio file and get back the URL of a cleaned WAV file.

You can choose between three denoising models with the `model` field: `mossformer2_se_48k` (the default), `cmgan` and `resemble_denoiser`. Each request processes one audio file.

## Features
- **Three denoising models**: `mossformer2_se_48k` (default), `cmgan` and `resemble_denoiser`, selectable per request.
- **Common audio formats in**: the input can be wav, mp3, m4a and other common audio files.
- **WAV out**: the result is a single WAV file URL.
- **Long clips with MossFormer2**: `force_sliding_window` forces sliding-window decoding for the `mossformer2_se_48k` model regardless of clip length.
- **Chunked batches with Resemble Denoiser**: `batch_process_chunks` processes 30-second chunks in batches for throughput when `model` is `resemble_denoiser`.

## Use Cases
1. **Podcast and interview cleanup**: remove room hum, traffic or fan noise from voice recordings before editing.
2. **Speech-to-text preprocessing**: clean noisy recordings before sending them to a transcription service.
3. **Call and meeting recordings**: make recorded calls easier to listen to.
4. **Voice-over drafts**: clean up voice takes recorded outside a studio.

## Visual Examples
### Example Input
`audio`: [Listen to the example input](https://blog.api.market/wp-content/uploads/2026/11/speech-enhancer-noisy-w15-input-api-market.wav) (a 10-second read-speech clip mixed with pink noise)

Other fields: `model` `mossformer2_se_48k`, `batch_process_chunks` `false`, `force_sliding_window` `false`.

### Example Output
[Listen to the example output](https://blog.api.market/wp-content/uploads/2026/11/speech-enhancer-output-mepsk5y5-api-market.wav)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `audio` | string (URL) | Yes |  |  | Noisy audio file (wav/mp3/m4a/etc.) to denoise |
| `model` | string | No | `mossformer2_se_48k` | `mossformer2_se_48k`, `cmgan`, `resemble_denoiser` | Choose a model to run |
| `force_sliding_window` | boolean | No | `false` |  | Only applies to mossformer2; otherwise ignored. Forces sliding-window decoding regardless of clip length |
| `batch_process_chunks` | boolean | No | `false` |  | Only applies to resemble_denoiser; process 30-second chunks in batches for throughput |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.001 per API unit.
- **1 API unit = 1 successful request with up to 4 seconds of processing time.** Longer jobs bill one more unit for each started 4-second block of processing, so a request that needs 4.1 to 8 seconds of processing costs 2 units ($0.002).
- Processing time grows with the length of the audio and the model you choose. Time spent waiting in the queue is not billed.
- **Example cost**: the example request (10 seconds of audio, `mossformer2_se_48k`) took 4.08 seconds of processing, which is 2 API units, so it cost $0.002.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/speech-enhancer-playmore-speech-enhancer`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/speech-enhancer-playmore-speech-enhancer/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "bda37cf8cb38f5b677514933634a281b263a04225f7b2bf62c1c1b8748d21ae6",
    "input": {
      "audio": "https://blog.api.market/wp-content/uploads/2026/11/speech-enhancer-noisy-w15-input-api-market.wav",
      "model": "mossformer2_se_48k",
      "batch_process_chunks": false,
      "force_sliding_window": false
    }
  }'
```

Response (201 Created):
```json
{
  "id": "mepsk5y541rg80d1mvnanc4520",
  "version": "bda37cf8cb38f5b677514933634a281b263a04225f7b2bf62c1c1b8748d21ae6",
  "status": "starting",
  "created_at": "2026-11-04T14:16:06.176Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/speech-enhancer-playmore-speech-enhancer/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "mepsk5y541rg80d1mvnanc4520",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/11/speech-enhancer-output-mepsk5y5-api-market.wav",
  "error": null,
  "created_at": "2026-11-04T14:16:06.176Z",
  "started_at": "2026-11-04T14:18:18.718Z",
  "completed_at": "2026-11-04T14:18:22.795Z"
}
```

`output` is a single URL string pointing to the cleaned WAV file.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `audio` or a `model` that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/speech-enhancer-playmore-speech-enhancer";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "bda37cf8cb38f5b677514933634a281b263a04225f7b2bf62c1c1b8748d21ae6", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "audio": "https://blog.api.market/wp-content/uploads/2026/11/speech-enhancer-noisy-w15-input-api-market.wav",
  "model": "mossformer2_se_48k",
  "batch_process_chunks": false,
  "force_sliding_window": false
}).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/speech-enhancer-playmore-speech-enhancer"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "bda37cf8cb38f5b677514933634a281b263a04225f7b2bf62c1c1b8748d21ae6", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


print(create_and_wait_for_prediction({
    "audio": "https://blog.api.market/wp-content/uploads/2026/11/speech-enhancer-noisy-w15-input-api-market.wav",
    "model": "mossformer2_se_48k",
    "batch_process_chunks": False,
    "force_sliding_window": False
}))
```

## FAQ
- **Which model should I pick?**
  - `mossformer2_se_48k` is the default. `cmgan` and `resemble_denoiser` are alternatives; try each on a sample of your own recordings and keep the one that sounds best.
- **What audio formats can I send?**
  - The `audio` field accepts a URL to wav, mp3, m4a and other common audio files. The output is always a WAV file.
- **What do `force_sliding_window` and `batch_process_chunks` do?**
  - `force_sliding_window` only affects `mossformer2_se_48k` and forces sliding-window decoding regardless of clip length. `batch_process_chunks` only affects `resemble_denoiser` and processes 30-second chunks in batches. Each is ignored by the other models.
- **How much does a request cost?**
  - $0.001 for each started 4-second block of processing time. The 10-second example clip took 4.08 seconds of processing and cost $0.002 (2 units).
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page.


Remove background noise from speech recordings with Playmore Speech Enhancer (MossFormer2, CMGAN or Resemble Denoiser) and get a clean WAV file. $0.001 per 4 seconds of processing, pay as you go.