Syntony SDK runs multilingual transcription, speaker diarization and de-identification in one realtime pass, entirely on device — iOS, Android and web. Raw audio never leaves the process. Partials render live as people speak; the moment recording stops, your app receives the de-identified transcript plus a separate re-identification map to rehydrate it — where that map lives is your call, not ours.
closed beta · realtime on device · zero audio egress
Synthetic sample — names and numbers are invented.
Audio goes in; a speaker-attributed, de-identified transcript comes out — partial results in realtime while people speak, the complete transcript the moment recording stops. Every stage runs in-process on the device — there is no server half.
State-of-the-art multilingual models run in-process — nothing streams to a cloud ASR. Voice-activity detection trims silence before it costs you compute.
Speaker embeddings segment the conversation into turns — who said what, computed locally, with no voiceprint ever transmitted.
A deterministic engine tokenizes structural identifiers — phone, date of birth, health-insurance number, address — every time. On-device NER catches spoken names on a best-effort basis. Your app receives stable tokens in place of everything the engine detects, plus a separate re-identification map that can rehydrate them — the SDK emits the map and stores nothing.
Synthetic example — names and numbers are invented.
Drop the pipeline into your app. Sessions are local objects, events are typed, and de-identified text is all that streams during capture — the re-identification map is handed over separately when recording stops, yours to protect.
API preview — shapes may change before release.
import SyntonySDK
let session = try SyntonySession(
languages: [.english, .french, .spanish],
redaction: .structuralAndNames
)
for await event in session.transcribe(mic: .default) {
switch event {
case .partial(let seg): render(seg) // realtime, on device only
case .final(let seg): store(seg.deidentified)
}
}
let map = session.reidentificationMap // yours to store; the SDK keeps nothingval session = SyntonySession(
languages = listOf(Language.EN, Language.FR, Language.ES),
redaction = Redaction.StructuralAndNames,
)
session.transcribe(Microphone.DEFAULT).collect { event ->
when (event) {
is Partial -> render(event.segment) // realtime, on device only
is Final -> store(event.segment.deidentified)
}
}
val map = session.reidentificationMap // yours to store; the SDK keeps nothingimport { SyntonySession } from "@syntony/sdk";
const session = await SyntonySession.create({
languages: ["en", "fr", "es"],
redaction: "structural+names",
});
for await (const event of session.transcribe(stream)) {
if (event.type === "final") {
store(event.segment.deidentified); // audio never left the tab
}
}
const map = session.reidentificationMap; // yours to store; the SDK keeps nothingThe pipeline ships as a single compiled unit per platform — not three parallel implementations drifting apart. A fix lands everywhere at once.
C FFI on iOS, JNI on Android, WebAssembly in the browser. Each adapter is a binding layer, not a rewrite — platform-native packaging on top.
De-identification is one shared Rust core: the same utterance produces the same tokens on every platform — the phone in the exam room, the desktop at the clinic workstation — so a re-identification map made on one client can rehydrate the transcript on another.
Security by design, not by policy: the architecture is the compliance story. Built for teams answering to Loi 25, PIPEDA, GDPR or HIPAA — the cheapest byte to protect is the one that was never collected.
Syntony SDK is in closed development. Request access by email and we’ll be in touch as the private beta opens.
From the team behind MedicalScribe — Syntony’s clinical dictation product for Québec physicians, built on this pipeline.
Opens your mail client with a short template — answered by email. Private beta · no newsletter, one reply.