The SDK
A file you embed — not a service you call.
ApneaSense is a detection engine — a 56.4 KB on-device model plus the event pipeline that makes it usable. You feed it microphone frames; it returns candidate acoustic events and quality state. No inference backend, no per-call cloud cost, no audio leaving the device.
What the production pipeline can return
The product contract and the published research benchmark are related, but they are not the same claim. The contract below describes available fields; the validation note states exactly which tasks have published metrics.
- Snore candidates — start, end, duration, acoustic type and confidence. The published benchmark covers 1-second snore-segment classification.
- Breathing-pattern candidates — start, end, duration, pause-like or shallow-breathing-like label, and confidence. The published benchmark covers 200-second breathing-window classification; boundary and duration behavior are evaluated separately in the buyer pilot.
- Session summaries — valid monitoring time, quality state, candidate counts and optional product-defined nightly indices. These are production outputs, not clinical measurements.
Any level can run as a real-time stream — emitted per event as the night runs — or be read as a nightly summary.
The contract — what goes in, what comes out
The whole interface, on purpose: raw mic frames in, structured candidate events out. Fitting the stream, thresholds and quality handling to your product is part of the pilot, not something we hide behind a generic accuracy number.
feed(audioFrames, sampleRate)
- raw mic PCM, mono, any sample rate — the engine resamples
- plus a session start time and a signed license key
- never features — the front-end stays inside the engine
- SnoreSnoreEvent { start, end, duration, type, dominantFreqHz, confidence }
- BreathingBreathingEvent { start, end, duration, type (pause | shallow), confidence }
- Both + indices+ SessionSummary { duration, event counts, valid-detection time, optional nightly indices }
- throughoutEngineStatus { warming-up | valid | too-noisy }
- optionalAudioSegment { event-aligned PCM } — handed back in memory; you decide whether to keep it
Your audio — your device, your call
The engine is stateless: it never holds, stores, or uploads audio. And because you own capture, the night's raw audio is already in your hands — keep it on-device if your use case needs it (research re-analysis, building your own corpus, audit playback), or drop it. "Audio never leaves the device" is the privacy story; "you can retain it on-device" is the research one — both are true at once. Whatever you store, the data-handling responsibility sits cleanly on your side.
What never leaves the engine
Separate from your audio — these stay inside, for anyone: extracted features, per-frame scores, model weights, thresholds, and the gating internals. That single boundary is both the privacy line and the IP line.
What ships
- The engine — the 56.4 KB model (9,416 INT8 parameters, 0.064 ms inference) plus the event pipeline, built for your platform: CoreML, TFLite, or an embedded chip. You embed an engine, not a raw model to interpret.
- The integration kit — a clean API, a sample app, and the docs. Mic frames in, events out.
- The validation pack — task definitions, methodology, per-seed metrics and code behind the published numbers, plus the pilot results from your environment. Your team decides what is suitable for its technical and regulatory documentation.
- Source in escrow — you embed a compiled engine; the source sits in escrow, so you're never dependent on us still being here.
How integration goes
Mic frames in, candidate events out. It runs on the device, so there is no inference server to stand up. Actual integration effort depends on capture, microphone behavior, quality gating, UX and your evidence requirements; the pilot makes that effort visible before a license commitment.
- On-device — runs on the phone or chip
- No cloud — audio never leaves the device
- Every night, real-time — a live stream your product can build on, not a morning batch
ApneaSense is detection only. What your product does with the events — surface them, log them, act on them — is your product, and your call. We don't respond, treat, or intervene.
Start with a small pilot
The first step isn't a contract. It's a focused, paid pilot — your device, your environment, a few nights of real data — from $15k, and creditable toward the license if you go ahead. That's where you benchmark it in your context, on your hardware, against your bar; we cover our time and prove the fit. Not a big commitment, not a long procurement.
If it proves out, the standard next step is a license — you embed the engine and integrate it yourself. That's the path that keeps you fast and keeps us out of your way.
Engagements start with a paid pilot — from $15k, creditable toward a license. License terms scoped to how you ship.
Compliance
ApneaSense is a detection engine — not a medical device, and not FDA-cleared. If you ship it inside a regulated product, the regulatory responsibility is yours and is addressed in the license. We provide the applicable technical materials and pilot evidence; your team determines whether they are sufficient for its intended use.
Tell us what you're building.
We'll send the paper and the code, and scope a small pilot — your device, a few nights.