---
title: "WebRTC + AI Noise Suppression in 2026: Krisp, RNNoise, and the BVC Pricing Shift"
description: "Krisp BVC went paid May 1 2026, RNNoise is unmaintained, and WebRTC's built-in NS is not enough for production voice AI. Here is the 2026 architecture for browser noise suppression."
canonical: https://callsphere.ai/blog/vw5e-webrtc-ai-noise-suppression-krisp-rnnoise-patterns-2026
category: "AI Engineering"
tags: ["WebRTC", "Noise Suppression", "Krisp", "RNNoise", "Audio AI"]
author: "CallSphere Team"
published: 2026-03-17T00:00:00.000Z
updated: 2026-05-07T16:29:46.080Z
---

# WebRTC + AI Noise Suppression in 2026: Krisp, RNNoise, and the BVC Pricing Shift

> Krisp BVC went paid May 1 2026, RNNoise is unmaintained, and WebRTC's built-in NS is not enough for production voice AI. Here is the 2026 architecture for browser noise suppression.

> Two things changed the noise-suppression calculus in 2026: Krisp BVC moved to paid usage on May 1, and RNNoise stopped getting maintenance updates from Mozilla. Production WebRTC apps now have to make a real decision — pay for Krisp/Telnyx VIVA, ship RNNoise WASM yourself, or rely on WebRTC's built-in NS3 and accept the quality hit.

## Why this matters

WebRTC's built-in noise suppressor (NS3, the Speex/WebRTC AEC3 chain) is fine for two-way human conversation in moderate environments. It is not fine for AI voice agents, where ASR and turn-detection are unforgiving — even 50 ms of background TV chatter can trigger a false interruption, derail a tool call, or push your end-pointing model into a hallucination. In 2026, every serious voice-AI vendor (LiveKit, Daily, Telnyx, Vonage, Twilio) ships a deep-learning suppressor on top of WebRTC's classic chain.

The market has bifurcated. Krisp BVC v3 is the gold standard but introduced metered pricing for SDK consumers in May 2026. RNNoise, originally a Mozilla project that married DSP to a small RNN, still works and compiles cleanly to WebAssembly — but it has not been maintained since 2024 and its model is showing its age on modern noise types (mechanical keyboard chatter, baby cries, fan noise from data centers). Newer entrants — Telnyx VIVA, Picovoice Koala, NVIDIA Maxine — split the difference with mid-tier pricing and on-device execution.

## Architecture

```mermaid
flowchart LR
  Mic[Browser Mic] --> AWN[AudioWorkletNode]
  AWN --> WASM[Noise Suppressor WASM
Krisp / RNNoise / Koala]
  WASM --> AEC[WebRTC AEC3]
  AEC --> RTP[RTP Encode Opus]
  RTP --> Gateway[Pion Go gateway 1.23]
  Gateway --> Agent[Voice Agent Pod]
```

## CallSphere implementation

CallSphere runs noise suppression in two places — server-side for inbound PSTN calls hitting the SIP gateway, and client-side for browser WebRTC sessions:

- **Real Estate (OneRoof)** — Inbound buyer calls land on the Pion Go gateway 1.23. SIP-arriving audio passes through a server-side suppressor before NATS-forwarding to the 6-container agent pod (CRM, MLS, calendar, SMS, audit, transcript). See [/industries/real-estate](/industries/real-estate).
- **/demo browser path** — The marketing site runs RNNoise WASM in an AudioWorkletNode before audio ever leaves the tab. The same WebRTC pipeline supports Krisp SDK as a paid upgrade for affiliates and enterprise tenants. Try it at [/demo](/demo).
- **HIPAA + SOC 2** — The cleaned audio is logged into the audit pipeline (1 of 115+ tables) only for clinical and legal verticals where transcripts are part of the record-of-care.

Across 37 agents, 90+ tools, 6 verticals, and HIPAA + SOC 2, the same noise pipeline ships to every tenant. Pricing remains $149/$499/$1499; 14-day [/trial](/trial); 22% affiliate at [/affiliate](/affiliate).

## Build steps with code

```javascript
// 1. Load RNNoise WASM into an AudioWorklet
const ctx = new AudioContext({ sampleRate: 48000 });
await ctx.audioWorklet.addModule("/rnnoise-processor.js");

// 2. Build the graph: mic -> RNNoise -> destination -> RTCPeerConnection
const stream = await navigator.mediaDevices.getUserMedia({
  audio: {
    echoCancellation: true,    // keep WebRTC AEC3
    noiseSuppression: false,   // disable WebRTC NS3 (we use RNNoise)
    autoGainControl: true,
  },
});
const source = ctx.createMediaStreamSource(stream);
const rnnoise = new AudioWorkletNode(ctx, "rnnoise-processor");
const dest = ctx.createMediaStreamDestination();
source.connect(rnnoise).connect(dest);

// 3. Add the cleaned track to the peer connection
const pc = new RTCPeerConnection({ iceServers });
dest.stream.getAudioTracks().forEach(t => pc.addTrack(t, dest.stream));

// 4. (Optional, paid) swap RNNoise for Krisp SDK at runtime
async function upgradeToKrisp(apiKey) {
  const krisp = await import("@krisp-ai/sdk");
  await krisp.init({ apiKey });
  // replace the AudioWorkletNode in the graph
}
```

## Pitfalls

- **Stacking three suppressors** — running WebRTC NS3 + RNNoise + a server-side suppressor over-suppresses speech and erases sibilants. Pick one client-side and at most one server-side.
- **Using `getUserMedia` constraints alone** — `noiseSuppression: true` triggers NS3, which is weaker than RNNoise. Set it false when you ship a custom worklet.
- **Forgetting AEC** — RNNoise is a noise suppressor, not an echo canceller. Keep AEC3 on or you will get loop howl on speakerphones.
- **Loading RNNoise via ``** — main-thread WASM blocks rendering. Always run inside an AudioWorklet.
- **Assuming Krisp is free in 2026** — BVC is metered as of May 1, 2026; budget for it or fall back to RNNoise/Koala.

## FAQ

**Is RNNoise still safe to ship?** Yes for English-dominant deployments and stationary noise. For diverse noise types (children, dogs, traffic), upgrade to Koala or Krisp.

**Can I run Krisp SDK in the browser?** Yes — Krisp ships a WebAssembly SDK that runs in an AudioWorklet, same pattern as RNNoise.

**Does noise suppression hurt ASR?** Aggressive suppression can over-attenuate sibilants and lower WER. Tune the gain floor and validate WER on your corpus.

**What about server-side suppression?** Pion supports passing audio through a custom `InterceptorFactory`; you can drop a Go-cgo binding to RNNoise or Koala there.

**Does Opus already do this?** Opus is a codec; it preserves what you feed it. If you feed noise, you compress noise. Suppression must happen before the encoder.

## Sources

- [https://bloggeek.me/webrtc-noise-suppression/](https://bloggeek.me/webrtc-noise-suppression/)
- [https://krisp.ai/blog/scaling-webrtc-voice-quality-across-platforms/](https://krisp.ai/blog/scaling-webrtc-voice-quality-across-platforms/)
- [https://gcore.com/blog/noise-reduction-webrtc](https://gcore.com/blog/noise-reduction-webrtc)
- [https://noisereducerai.com/rnnoise/](https://noisereducerai.com/rnnoise/)
- [https://docs.livekit.io/transport/media/noise-cancellation/](https://docs.livekit.io/transport/media/noise-cancellation/)

Hear the difference at [/demo](/demo), see plans at [/pricing](/pricing), or [/trial](/trial) for 14 days free.

---

Source: https://callsphere.ai/blog/vw5e-webrtc-ai-noise-suppression-krisp-rnnoise-patterns-2026