Noise Cancellation
Get an API key
Early beta — not for distribution

Crystal-clear voice.
Anywhere your audio goes.

One API request removes background noise, hum, traffic, keyboards, fans and crowd chatter from any voice stream. Plug it into your contact center, recording pipeline, transcription engine or voice AI — without rebuilding a thing.

Before Noisy audio
After One API request

Designed for teams that ship voice products

Real‑time
Live streaming & batch
Studio quality
Speech preserved, noise gone
Drop‑in
REST & WebSocket, any stack
Private by default
Never used for training

The problem

Background noise
silently breaks your product.

Every barking dog, traffic hum, keyboard click and crowd chatter that bleeds into your audio costs your team something: a frustrated customer, a misheard transcript, a refunded order, a missed sale. Most voice apps just live with it because building a real fix means months of audio research, GPUs, and edge cases.

Customers speak from anywhere
Cars, cafes, open-plan offices, factory floors. Your agents strain to hear and your transcripts miss critical details — through no fault of either.
Speech-to-text suffers
Transcription accuracy collapses on noisy phone audio. Your model isn't broken — the input is. Clean the audio first and downstream quality jumps with no model change.
Building this in-house is huge
Hiring audio ML engineers, training a model, deploying it on real-time infrastructure, then maintaining it forever. Ship customer value this afternoon instead.

Use cases

Built for any product that touches a microphone.

Drop the API into an existing voice flow without touching the rest of your stack. Streaming for live audio, batch for recordings — same API, same results.

Customer support & sales

Cut handle time. Agents stop saying "can you repeat that?". Recorded conversations become legible for QA. Higher CSAT, lower escalation rate.

Telemedicine

Doctors hear patient details the first time. Waiting-room chatter, traffic, breathing artifacts — gone. Cleaner recordings simplify clinical review.

Podcasts & UGC

Creators record from anywhere — bedrooms, hotel rooms, cafes. Your platform delivers broadcast-quality audio without asking them to buy a studio.

Conferencing & collab

Meetings sound like everyone's in the same quiet room. Dogs, doorbells, construction outside — suppressed in real time, no client install.

Voice AI & transcription

Drop in front of any speech-to-text or voice-agent stack. Cleaner input means dramatically higher accuracy on noisy real-world recordings.

Online learning

Students join from anywhere. Background TV, siblings, traffic — cleaned before the lecturer or the captioner has to deal with it.

What you get

Less friction.
Better customers.
Faster shipping.

Drop-in integration

Standard REST and WebSocket. No custom protocols, no SDK lock-in, no audio engineering required. If you can curl an API, you can ship this.

Real-time, end‑to‑end

Stream 10-millisecond audio frames over WebSocket and get clean audio back in the same connection. Suitable for live conversations, voice agents, and interactive recording UIs.

Private by default

Audio is never used to train anything. Batch files are encrypted at rest and auto-deleted on a schedule you control. SOC 2 alignment in progress.

Pay only for clean seconds

Usage-based pricing on actual audio seconds processed — not seats, not connections, not minimums. Generous free tier for development and small teams.

How it works

Three steps. Two flavors. One bill.

You send audio. We clean it. You get audio back. Pick the mode that matches your product — live streaming for interactive flows, batch for files at rest. Both share the same authentication, the same pricing, and the same quality.

1

Send your audio

Stream raw audio frames over a secure WebSocket, or POST a file (WAV, MP3, FLAC, OGG) to a one-shot endpoint. Authenticated with a Bearer key.

2

Our engine cleans it

A purpose-built noise-cancellation engine isolates the human voice and suppresses everything else: hum, hiss, traffic, keyboards, fans, background chatter. Speech-aware, not just a filter.

3

You get clean audio back

Streaming: a clean frame for every frame you sent, in order. Batch: a URL to download the processed file when it's done. Same sample rate in, same out.

Streaming

Live audio, in and out, on a single WebSocket. Use it when latency matters: live conversations, voice agents, live captions.

  • ✓  10 ms PCM-16 frames in & out
  • ✓  Bidirectional, single connection
  • ✓  Auto-reconnect (SDK)
  • ✓  Per-tier concurrency budget

Batch

Upload a file, get a clean file back. Use it for recordings, voicemails, podcasts, archive processing.

  • ✓  WAV, MP3, FLAC, OGG in
  • ✓  Pre-signed direct upload
  • ✓  Async with status polling
  • ✓  Auto-delete on a schedule

Quickstart

Clean your first file in three steps.

You will need an API key. Request one here — we onboard beta partners individually.

1

Configure your key

Export your API key. Keep it server-side — never ship it in browser JavaScript or a mobile binary.

shell
# export your key once per shell
export NC_API_KEY="sk_your_api_key_here"
export NC_BASE_URL="https://api-noise-cancellation.us.tech"
2

Submit a job & upload audio

Ask the API for an upload URL. The response contains a pre-signed URL valid for 15 minutes — you upload directly to storage from anywhere with internet access.

# 1. Ask for an upload URL
RESP=$(curl -sS -X POST "$NC_BASE_URL/v1/enhance" \
  -H "authorization: Bearer $NC_API_KEY" \
  -H "content-type: application/json" \
  --data '{"content_type": "audio/wav"}')

JOB_ID=$(echo "$RESP" | jq -r .job_id)
UPLOAD_URL=$(echo "$RESP" | jq -r .upload_url)

# 2. Upload your audio directly to the pre-signed URL
curl -sS -X PUT "$UPLOAD_URL" \
  -H "content-type: audio/wav" \
  --data-binary @my-recording.wav
3

Start, poll, download

Kick the job, poll for completion, and download.

# 3. Start the job (queues for processing)
curl -sS -X POST "$NC_BASE_URL/v1/enhance/$JOB_ID/start" \
  -H "authorization: Bearer $NC_API_KEY"

# 4. Poll until done
while true; do
  STATE=$(curl -sS "$NC_BASE_URL/v1/jobs/$JOB_ID" \
    -H "authorization: Bearer $NC_API_KEY")
  STATUS=$(echo "$STATE" | jq -r .status)
  [ "$STATUS" = "completed" ] && break
  [ "$STATUS" = "failed" ]    && exit 1
  sleep 2
done

# 5. Download the cleaned audio
DL=$(echo "$STATE" | jq -r .download_url)
curl -sS -o cleaned.wav "$DL"

That's the whole batch flow.

No queues to manage, no servers to provision, no audio-engineering background needed. Same shape works for short clips and long recordings alike, up to the per-file size limit.

Streaming

Live audio in & out, one WebSocket.

For live conversations and voice agents, open a WebSocket and stream raw 10‑millisecond PCM-16 audio frames. You get a cleaned frame back for every frame you send, in order, on the same connection.

Endpoint
wss://api-noise-cancellation.us.tech/v1/stream
Audio format
  • Sample rate: 48 kHz
  • Format: PCM-16 little-endian
  • Channels: 1 (mono)
  • Frame size: 480 samples (10 ms)
Auth

Send your key as a header on the upgrade request, or append ?api_key=<key> for browsers.

stream.py
import asyncio, os, websockets

async def clean_stream(mic_frames):
    """Yield cleaned 10ms PCM-16 frames for each frame from `mic_frames`."""
    url     = "wss://api-noise-cancellation.us.tech/v1/stream"
    headers = {"authorization": f"Bearer {os.environ['NC_API_KEY']}"}

    async with websockets.connect(url, extra_headers=headers) as ws:
        async def send_loop():
            async for frame in mic_frames:        # 960 bytes/frame
                await ws.send(frame)

        send_task = asyncio.create_task(send_loop())
        try:
            async for clean_frame in ws:        # clean PCM-16
                yield clean_frame
        finally:
            send_task.cancel()

Close codes

1000Normal close
1008Concurrency limit / policy
1011Server backpressure
4401Invalid or missing API key

API reference

Five endpoints. That's all of it.

Base URL: https://api-noise-cancellation.us.tech. All endpoints require Authorization: Bearer <key> except /healthz and /readyz.

POST /v1/enhance Reserve a job & get an upload URL
Request body
{
  "content_type": "audio/wav"
}

Accepted: audio/wav, audio/mpeg, audio/flac, audio/ogg.

Response (202)
{
  "job_id": "5aef129a-...",
  "upload_url": "https://...",
  "upload_expires_in_sec": 900,
  "content_type": "audio/wav"
}
POST /v1/enhance/{job_id}/start Queue the uploaded audio for processing
Path parameters

job_id — the id returned by /v1/enhance.

Errors
  • 400 nothing uploaded yet
  • 404 wrong owner / not found
  • 409 already started / completed
Response (202)
{
  "job_id": "5aef129a-...",
  "status": "queued"
}
GET /v1/jobs/{job_id} Poll status & collect the download URL
Status values
  • pending_upload
  • queued
  • processing
  • completed
  • failed
Response (200)
{
  "job_id": "5aef129a-...",
  "status": "completed",
  "created_at": "2026-05-11T18:45:26Z",
  "completed_at": "2026-05-11T18:45:30Z",
  "download_url": "https://...",
  "download_expires_in_sec": 3600
}
WS /v1/stream Bidirectional real-time streaming

Each WebSocket message is a single 480-sample PCM-16 frame (960 bytes). Send and receive frames in any order; cleaned frames return in send order. See the streaming guide for example code.

GET /healthz · /readyz Liveness & readiness

No auth required. /readyz also reports backing-store health.

$ curl https://api-noise-cancellation.us.tech/readyz
{"status":"ok","db":"ok","redis":"ok"}

SDKs

One install. Two lines of code.

Py

Python SDK

Sync & async, mic helper, batch one-liner

Available
# install
pip install noise-cancellation

# clean a file end-to-end
from noise_cancellation import Client
Client(api_key="sk_...").enhance_file(
    "in.wav", "out.wav",
)
JS

Node / Browser SDK

Server-side & AudioWorklet

Soon
// install (preview)
npm install @noise-cancellation/sdk

// clean a file end-to-end
import { Client } from "@noise-cancellation/sdk";
await new Client({ apiKey: "sk_..." })
    .enhanceFile("in.wav", "out.wav");

Errors & limits

Predictable failure modes.

All errors return a JSON body with a detail field. Authentication failures use HTTP 401 for REST and close code 4401 for WebSocket.

HTTP error codes

400Malformed request body
401Invalid / missing API key
404Job not found / not yours
409Job state conflict
413File exceeds 100 MB cap
429Rate limit exceeded
5xxServer error — retry with backoff

Default rate limits

Concurrent streams5 / key

Higher tiers and custom limits available on request.

Batch jobs100 / minute

Burst-friendly with token-bucket smoothing.

Max file size100 MB

~ 30 minutes of 48 kHz mono WAV.

Artifact retention30 days

Configurable per workspace.

FAQ

Common questions.

Will it work with my existing transcription / voice-AI stack?
Yes. We output the same sample rate, format and channel count we received, so we slot in front of any downstream speech-to-text, voice-agent, or recording pipeline without changing the rest of your stack.
Do you store my audio?
Streaming audio is never persisted — frames pass through and are dropped. Batch files are encrypted at rest, auto-deleted on a schedule you control (default 30 days), and never used to train any model. Your customer data stays yours.
How is this different from a normal high-pass / noise gate filter?
Traditional filters cut frequency bands — they remove some noise but also remove a lot of speech, and they fail completely on noise that overlaps with the voice (crowd chatter, keyboards, traffic). Our engine learned what human speech sounds like and isolates it, leaving voice intact while suppressing everything else, including non-stationary, voice-overlapping interference.
What's the latency?
Streaming is real-time: cleaned frames return on the same WebSocket connection as you send raw frames, designed to stay well under the latency threshold humans perceive as "delayed" in conversation. Batch jobs run as quickly as the audio allows.
How is pricing structured?
Usage-based, per second of audio processed. No seat fees, no per-connection fees, no minimums in beta. Volume discounts and committed-use pricing for high-volume workloads — talk to us.
Can I self-host?
On-premise and VPC-private deployments are available for enterprise customers with data-residency or HIPAA requirements. Reach out to discuss.
Which languages does it support?
It's language-agnostic: it isolates the human voice based on acoustic properties shared across languages, so it works on any spoken language without configuration. We have validated quality on English phone-codec audio and on a range of European languages.

Ready to ship cleaner audio?

Beta access is free for development and small production traffic. Tell us a little about what you're building and we'll get you a key.