Speech-to-textthat never leavesthe device.
Dersch is an embeddable speech-to-text engine for web apps and browser extensions. Whisper and Parakeet-grade accuracy, accelerated by WebGPU. The audio is transcribed in your user’s browser and never touches a server, so you add voice without adding a subprocessor.
Every voice feature ships with a compliance review attached.
The moment you send a user's audio to a transcription API, you stop adding a feature and start adding a data subprocessor. That trips a months-long review that your customers' security teams run on every company that touches their data. The voice feature waits while the paperwork moves.
With cloud ASR
You become a subprocessor.
- Negotiate and sign a BAA
- Answer a security questionnaire (SIG Lite ~150 to SIG Full 1,000+ questions)
- Sign a DPA with Standard Contractual Clauses
- Add the vendor to your subprocessor register
- Give customers 30 days notice, with an objection window
- Re-assess the vendor every year, and own breach liability
In regulated industries each review runs for weeks, and a downstream customer can object and walk.
With Dersch
You add a dependency.
- The audio is transcribed on the device and never reaches us.
- No data flows to Dersch, so embedding it adds no subprocessor.
- It is a library, like lodash, not a cloud service.
You delete the data-processor gauntlet. A light software review may still apply. See the FAQ.
Three lines. Then it runs on the device.
Dersch is a component, not a cloud. This is the entire integration path.
import { Transcriber } from "@dersch/voice";
// loads + caches an open model, runs on-device
const dersch = await Transcriber.load({
model: "parakeet-0.6b",
});
const { text } = await dersch.transcribe(audio);
// the audio never left the browser
- 01
Install the package
One npm dependency. No account to provision, no infrastructure to stand up, no API keys for an audio service, because there is no audio service.
- 02
The model runs in the browser
On first use, Dersch loads an open model and runs it with WebGPU acceleration, falling back to WASM. The weights are cached, so later loads are instant and work offline.
- 03
The audio stays on the device
Speech is transcribed locally and the text lands in your app. Nothing else leaves: the preview SDK has no telemetry, no heartbeat, no hidden calls. The only network traffic is the one-time model download.
Compliance by architecture, not by certificate.
Cloud transcription keeps your audio safe with promises: a BAA, a SOC 2 report, encryption in transit. Dersch keeps it safe with physics. The audio is transcribed where it is spoken, and never travels.
Microphone
Your user speaks
Dersch · in the browser
Transcribes on-device with WebGPU
Your app
Receives the text
Stays on the device
- The raw audio
- The transcript
- Any personal or protected information in the speech
Leaves the device
- Nothing today: no telemetry, no license pings, no hidden calls
- No audio · no transcript · no content
A careful customer may still run a light software or supply-chain review (does it phone home?). Dersch removes the data-processor gauntlet, not all scrutiny. This is not legal advice; confirm your obligations with your own compliance team.
Cloud-grade accuracy, on the device.
On-device used to mean mediocre. WebGPU changes the equation. Dersch runs open, named models like NVIDIA Parakeet and Whisper, not tiny CPU models. Lower word error rate is better.
| Model | Word error rate | Where it runs |
|---|---|---|
NVIDIA Parakeet 0.6BDersch On-device · WebGPU | ~6.0 to 6.7% | On-device · WebGPU |
Whisper large-v3 Cloud-grade reference | ~6.4% | Cloud-grade reference |
Picovoice (tiny, CPU) On-device · CPU / WASM | 13.6 to 17.5% | On-device · CPU / WASM |
Web Speech API Browser API · cloud fallback | mediocre | Browser API · cloud fallback |
Word error rates from the Open ASR Leaderboard and published vendor benchmarks, not our own measurements yet. Accuracy and speed depend on the end-user’s hardware; WebGPU performs best on modern desktop browsers.
~6%
word error rate on-device. Cloud-grade, not CPU-grade.
~40×
Parakeet throughput versus Whisper (RTFx)
0
audio bytes sent to a server
Cloud-grade voice. None of the cloud's baggage.
Latency, privacy, cost, compliance. On-device wins every axis that used to force a tradeoff, and it does it without a backend.
Private by architecture
The audio is transcribed on the device and never transmitted. Not a promise backed by a certificate. A property of where the work happens.
Zero infrastructure
No GPU clusters, no Kubernetes, no servers to scale or page you at 3am. Inference runs on your users' machines, so there is nothing to run.
Works offline and air-gapped
Once the model is cached it keeps transcribing with no network at all. Built for locked-down hospital, legal, and government environments.
No rate limits, no meter
Transcribe as much as you want, for as long as you want. There is no per-minute bill, because the audio never reaches a billing system.
One package, every web surface
Drop it into any web app or browser extension. Cross-platform across modern desktop browsers, shipped from a single npm install.
Open, named models
NVIDIA Parakeet and Whisper, not a proprietary black box. Benchmark the accuracy yourself, and audit exactly what runs on your users' devices.
Private and zero-infra. There is no backend to run.
‘Private’ usually means ‘stand up your own GPU cluster.’ Dersch runs on your users' devices, so inference happens with no servers at all. A different weight class from self-hosting.
Cloud + BAA
Deepgram, AssemblyAI, Wispr Flow
- Audio lives in
- the vendor's cloud
- Who runs infra
- the vendor
- You sign
- a BAA, you're a subprocessor
Self-hosted / on-prem
Deepgram, AssemblyAI on-prem
- Audio lives in
- your own servers
- Who runs infra
- you, GPUs and Kubernetes
- You sign
- a six-figure enterprise contract
On-device
DerschDersch
- Audio lives in
- the end-user's device
- Who runs infra
- nobody
- You ship
- an npm package
Open your network tab. Watch it stay empty.
The strongest proof is the one you can watch: real transcription running in your browser with no audio leaving the tab. The live demo is being wired up. Here is what it will show.
Transcript · on-device
“The audio is transcribed right here in the browser. Nothing is uploaded, nothing is stored on a server.”
Runs a ~200 MB model locally · best on desktop Chrome or Edge with WebGPU · loads only when you click.
A clean SDK, not a research demo.
The hard parts (streaming, voice activity, persistent caching, device-matrix reliability) are handled. You get a small, honest API.
import { Transcriber } from "@dersch/voice";
const dersch = await Transcriber.load({ model: "parakeet-0.6b" });
// record -> transcribe, entirely on-device
const { text } = await dersch.transcribe(audioBlob);
// live, low-latency partials as the user speaks
const session = dersch.stream({
onPartial: (t) => render(t),
onFinal: (t) => commit(t),
});
session.append(micChunk);
await session.stop();
- TypeScript-first, framework-agnostic
- WebGPU acceleration with WASM/CPU fallback
- Models cached locally, instant after first load, works offline
- Streaming partials today with Whisper; batch with Parakeet
- No telemetry, no audio upload, no hidden network calls
- Drop into any web app or browser extension
Transparent pricing. A real free tier.
No “contact sales” just to see a number. Start free, and talk to us only when you go commercial or need enterprise terms.
Open
$0
For side projects, learning, and non-commercial use.
- All open models
- On-device, unlimited transcription
- Community support
- Small usage cap
Pro
Most popular$199/mo
For commercial web apps and extensions.
- Commercial license
- Up to 3 apps · 10,000 monthly active devices
- Latest models
- Email support
- No sales call required
Enterprise
Custom
For regulated and security-conscious teams.
- SLA + priority support
- Compliance attestation docs
- Domain-tuned models
- Indemnification
The preview SDK has no license enforcement and phones home for nothing. Commercial licensing will use a key that carries no audio and no content. Usage is never metered, because the audio never reaches us. Prices indicative for launch.
Honest answers.
The questions a security team, and a skeptical engineer, will actually ask.
Do my customers need a BAA to use Dersch?
No. A Business Associate Agreement covers a vendor that receives protected health information. Because audio is transcribed on the device and never reaches us, we do not receive PHI, so there is no business-associate relationship to paper. (This is not legal advice; confirm with your own compliance team.)
Are you a subprocessor?
No. A subprocessor processes personal data on your behalf. No audio or transcript flows to Dersch, so embedding it adds no subprocessor to your register, and does not trigger the 30 day customer-notice cascade.
Does it work on phones?
Best on modern desktop browsers with WebGPU (Chrome and Edge today). Mobile support is limited. We would rather be honest than promise a parity we cannot deliver.
How big is the model, and what is the first load like?
The first load downloads a model, roughly 200 MB for the lightweight Whisper option and up to 1.3 GB for the largest Parakeet variant, then caches it for instant, offline-capable later loads. We do not claim “no download.”
Which models does Dersch run?
Open, named models: NVIDIA Parakeet and Whisper. You can benchmark them yourself. There is no proprietary black box.
How is it licensed and metered?
Today, in the preview, there is no license enforcement and the SDK makes no calls home. At launch a license key will validate entitlement. It will carry no audio and no content, so usage is never metered on our side, because it never reaches our side.
Can I run it offline?
Yes. Inference happens on your users' devices, so once the model is cached it keeps working with no network. Useful for air-gapped or locked-down environments.
Add voice without the paperwork.
Voice used to be the one feature you couldn’t ship without a compliance review, a GPU bill, and a security questionnaire. Now it is one npm install, and the audio never leaves your users’ devices.