Stream Denoise Progress

curl --request GET \
  --url https://api.munsit.com/api/v1/denoise/{denoiseId}/progress \
  --header 'x-api-key: <api-key>'

import requests

url = "https://api.munsit.com/api/v1/denoise/{denoiseId}/progress"

headers = {"x-api-key": "<api-key>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://api.munsit.com/api/v1/denoise/{denoiseId}/progress', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.munsit.com/api/v1/denoise/{denoiseId}/progress",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.munsit.com/api/v1/denoise/{denoiseId}/progress"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.munsit.com/api/v1/denoise/{denoiseId}/progress")
  .header("x-api-key", "<api-key>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.munsit.com/api/v1/denoise/{denoiseId}/progress")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<api-key>'

response = http.request(request)
puts response.read_body

{
  "stage": "processing",
  "pct": 50,
  "message": "<string>"
}

{
  "errorCode": "<string>",
  "errorMessage": "<string>"
}

{
  "message": "Denoising job not found"
}

GET

denoise

{denoiseId}

progress

Stream Denoise Progress

curl --request GET \
  --url https://api.munsit.com/api/v1/denoise/{denoiseId}/progress \
  --header 'x-api-key: <api-key>'

import requests

url = "https://api.munsit.com/api/v1/denoise/{denoiseId}/progress"

headers = {"x-api-key": "<api-key>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {'x-api-key': '<api-key>'}};

fetch('https://api.munsit.com/api/v1/denoise/{denoiseId}/progress', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.munsit.com/api/v1/denoise/{denoiseId}/progress",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.munsit.com/api/v1/denoise/{denoiseId}/progress"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.munsit.com/api/v1/denoise/{denoiseId}/progress")
  .header("x-api-key", "<api-key>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.munsit.com/api/v1/denoise/{denoiseId}/progress")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<api-key>'

response = http.request(request)
puts response.read_body

{
  "stage": "processing",
  "pct": 50,
  "message": "<string>"
}

{
  "errorCode": "<string>",
  "errorMessage": "<string>"
}

{
  "message": "Denoising job not found"
}

Subscribes to live progress events for a denoising job over Server-Sent Events (SSE). The connection emits a processing event as work advances and terminates with either a done event (carrying the final audio URL) or an error event.

Authentication

Requires API key authentication via x-api-key header.

Request

Path Parameters

Parameter	Type	Required	Description
`denoiseId`	string (UUID)	Yes	The `denoiseId` returned by `POST /denoise`.

Headers

Header	Value	Description
`Accept`	`text/event-stream`	Required to negotiate the SSE response.

Response

Status Code: 200 OK Headers:

Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

The body is an SSE stream. Each message is delivered as a data: line whose payload is a JSON object. The connection automatically closes after a terminal event (done or error), or after 15 minutes of inactivity. When you connect to an already-completed job, the server immediately emits the cached final event and closes — no need to poll separately.

Event Schema

The stage field discriminates the event:

Stage	Fields	Description
`processing`	`pct` (number, 0–100), `message` (string, optional)	Incremental progress update.
`done`	`url` (string), `denoiseId` (string)	Terminal success — `url` is the denoised audio URL.
`error`	`message` (string)	Terminal failure — human-readable error message.

Example Stream

data: {"stage":"processing","pct":15,"message":"Extracting audio"}

data: {"stage":"processing","pct":62,"message":"Running noise reduction"}

data: {"stage":"done","url":"https://cdn.munsit.com/denoising/user_123/5b1d2f7e_denoised.wav","denoiseId":"5b1d2f7e-3f81-4c2a-9c5d-7a2e91b4c7a1"}

Error Responses

404 Not Found — emitted as a JSON body, not as SSE:

{
  "message": "Denoising job not found"
}

401 Unauthorized

{
  "errorCode": "40101",
  "errorMessage": "Invalid or missing API key"
}

Example Usage

JavaScript (fetch + ReadableStream)

const denoiseId = "5b1d2f7e-3f81-4c2a-9c5d-7a2e91b4c7a1";

const res = await fetch(`https://api.munsit.com/api/v1/denoise/${denoiseId}/progress`, {
  headers: {
    'x-api-key': 'YOUR_API_KEY',
    'Accept': 'text/event-stream',
  },
});

const reader = res.body.getReader();
const decoder = new TextDecoder();
let buffer = "";

while (true) {
  const { value, done } = await reader.read();
  if (done) break;
  buffer += decoder.decode(value, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop() ?? "";

  for (const line of lines) {
    if (!line.startsWith("data: ")) continue;
    const event = JSON.parse(line.slice(6));
    if (event.stage === "processing") {
      console.log(`Progress: ${event.pct}%`, event.message);
    } else if (event.stage === "done") {
      console.log("Denoised audio ready:", event.url);
      return;
    } else if (event.stage === "error") {
      console.error("Denoising failed:", event.message);
      return;
    }
  }
}

Python (httpx)

import httpx, json

denoise_id = "5b1d2f7e-3f81-4c2a-9c5d-7a2e91b4c7a1"
url = f"https://api.munsit.com/api/v1/denoise/{denoise_id}/progress"
headers = {
    "x-api-key": "YOUR_API_KEY",
    "Accept": "text/event-stream",
}

with httpx.stream("GET", url, headers=headers, timeout=None) as r:
    for line in r.iter_lines():
        if not line or not line.startswith("data: "):
            continue
        event = json.loads(line[6:])
        if event["stage"] == "processing":
            print(f"Progress: {event['pct']}% — {event.get('message','')}")
        elif event["stage"] == "done":
            print("Denoised audio URL:", event["url"])
            break
        elif event["stage"] == "error":
            print("Failed:", event["message"])
            break

cURL

curl -N "https://api.munsit.com/api/v1/denoise/5b1d2f7e-3f81-4c2a-9c5d-7a2e91b4c7a1/progress" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Accept: text/event-stream"

Reconnecting: If you reconnect after a job has already finished, the server replays the cached terminal event immediately so clients never miss completion.

Authorizations

x-api-key

string

header

required

API key for authentication

Path Parameters

denoiseId

string<uuid>

required

The denoiseId returned by POST /denoise.

Response

SSE stream of denoising events. Each message is a data: <json> line where the JSON conforms to DenoiseProgressEvent.

Option 1
Option 2
Option 3

An SSE event payload for a denoising job. The stage field discriminates between processing, done, and error.

stage

enum<string>

required

Available options:

processing

pct

number

required

Completion percentage.

Required range: 0 <= x <= 100

message

string

Optional human-readable progress message.

Submit Denoise Job

List Denoise History

Getting Started

Text To Speech

Speech to Text

Voice Cloning

Voice Isolation

Translation

Tashkil

Stream Denoise Progress

Authentication

Request

Path Parameters

Headers

Response

Event Schema

Example Stream

Error Responses

Example Usage

JavaScript (fetch + ReadableStream)

Python (httpx)

cURL

Authorizations

Path Parameters

Response

​Authentication

​Request

​Path Parameters

​Headers

​Response

​Event Schema

​Example Stream

​Error Responses

​Example Usage

​JavaScript (fetch + ReadableStream)

​Python (httpx)

​cURL

Authorizations

Path Parameters

Response

Authentication

Request

Path Parameters

Headers

Response

Event Schema

Example Stream

Error Responses

Example Usage

JavaScript (fetch + ReadableStream)

Python (httpx)

cURL