kothok-edge-tts

A Microsoft Edge online text-to-speech client for Rust. Replicates the Edge browser "Read Aloud" WebSocket protocol. Returns the same 400+ neural voices across 140+ locales as streaming MP3 frames plus word-boundary metadata for highlighting.

Part of the KoThok e-reader ecosystem:

Built on tokio, tokio-tungstenite, rustls (ring), and serde. No system TLS or audio libraries required: everything compiles from source via cargo.

Architecture

Your text goes in, MP3 audio comes out:

flowchart LR
    A["Your text"] --> B["EdgeTts"]
    B --> C["Microsoft Edge<br/>TTS server"]
    C --> D["MP3 audio<br/>+ word timing"]
    D --> E["Your app"]

    style A fill:#dcfce7,stroke:#16a34a
    style B fill:#dbeafe,stroke:#2563eb
    style C fill:#fef3c7,stroke:#d97706
    style D fill:#dcfce7,stroke:#16a34a
    style E fill:#dbeafe,stroke:#2563eb

Each synthesize() call does 4 things:

1. Builds a DRM token (Microsoft requires it)
2. Opens a secure WebSocket to speech.platform.bing.com
3. Sends your text as SSML
4. Streams back MP3 chunks + word timing until done

Internal modules (auth, connection, protocol, ssml) are crate-private.

Network dependency

This crate talks to Microsoft's Edge TTS service over the internet. There is no offline mode and no bundled voices.

On a Kobo, pair this with kobo-core's wifi_toggle / wifi_status so the host app can bring the radio up before the first synthesize() and check connectivity before showing voice lists.

Install

cargo add kothok-edge-tts

Quick start

use kothok_edge_tts::{init_tls, EdgeTts, Engine, TtsEvent};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    init_tls(); // once, before the first connect

    let events = EdgeTts
        .synthesize("Hello world.", "en-US-EmmaMultilingualNeural", "+0%", "en-US")
        .await?;

    let mut audio = Vec::new();
    for ev in events {
        match ev {
            TtsEvent::Audio(bytes) => audio.extend_from_slice(&bytes),
            TtsEvent::WordBoundary { offset, text, .. } => {
                println!("word \"{text}\" at {offset} ticks");
            }
            TtsEvent::TurnEnd => {}
        }
    }
    // audio == raw MP3 (audio-24khz-48kbitrate-mono-mp3)
    Ok(())
}

Multi-language

Any Microsoft neural voice works. Just pass the voice short-name and BCP-47 lang tag:

# use kothok_edge_tts::*;
# async fn run() -> Result<(), Box<dyn std::error::Error>> {
EdgeTts.synthesize("Hello", "en-US-EmmaMultilingualNeural", "+0%", "en-US").await?;
EdgeTts.synthesize("নমস্কার", "bn-BD-NabanitaNeural", "+0%", "bn-BD").await?;
EdgeTts.synthesize("مرحبا", "ar-SA-ZariyahNeural", "+0%", "ar-SA").await?;
# Ok(()) }

Full voice list: Microsoft Speech language support

synthesize parameters

Swappable backend

EdgeTts implements the Engine trait. Implement it yourself to mock or swap backends:

# use kothok_edge_tts::*;
# use std::future::Future;
struct MockTts;
impl Engine for MockTts {
    fn synthesize(&self, _: &str, _: &str, _: &str, _: &str)
        -> impl Future<Output = Result<Vec<TtsEvent>, TtsError>> + Send
    { async { Ok(vec![TtsEvent::Audio(vec![0xFF; 100]), TtsEvent::TurnEnd]) } }
}

Token rotation

Microsoft rotates the SEC_MS_GEC_VERSION constant on Edge release cycles. A daily CI job detects when it goes stale (HTTP 403) and auto-creates a GitHub Issue with fix steps. Users should pin to the latest published version.

Acknowledgements

Protocol logic ported from edge-tts by rany2: the reference Python implementation. All credit for reverse-engineering the Edge Read-Aloud protocol goes to that project.

API reference

Complete alphabetical list of everything exported from this crate.

License

MIT (LICENSE).