How to Use Apple's SpeechAnalyzer (the On-Device Whisper Alternative in iOS 26 / macOS 26)

Read time: ~7 minutes. Key facts:

  • Apple’s SpeechAnalyzer + SpeechTranscriber API replaces SFSpeechRecognizer and ships in iOS 26 / macOS 26 (Speech framework).
  • It’s fully on-device — no audio leaves the machine (the old SFSpeechRecognizer sent audio to Apple’s servers by default).
  • In one independent benchmark it hit a 2.12% word error rate on clean speech / 4.56% on noisy, beating Whisper Small (3.74% / 7.95%) and running ~3× faster.
  • It’s modular: attach a SpeechTranscriber (raw words) or DictationTranscriber (formatted), plus a SpeechDetector for voice activity.
  • The tradeoff: ~30 locales vs Whisper’s 100+ languages.

Sourcing note: the API classes and Swift flow are from Apple’s official Speech framework docs and WWDC25 session 277; the benchmark numbers are from a single independent test by get-inscribe (English-only, read audiobook audio, one M2 Pro — their caveats, reported as measured, not universal). API details can shift between OS builds — confirm against the live docs. Links at the bottom.

If your app does transcription on an Apple platform, the calculus just changed. For years the choice was “Apple’s cloud-leaning SFSpeechRecognizer, or bundle Whisper yourself.” In iOS 26 / macOS 26, Apple’s new SpeechAnalyzer does fully on-device speech-to-text that — in at least one head-to-head — is more accurate and faster than Whisper Small, with nothing leaving the device. Here’s how to use it, and when it actually beats Whisper.

1. What SpeechAnalyzer is

SpeechAnalyzer is the new engine in Apple’s Speech framework (iOS 26 / macOS 26). It replaces SFSpeechRecognizer and takes a modular approach: you create an analysis session and attach the modules you need. In iOS 26 there are two:

  • SpeechTranscriber — speech-to-text. Use it when you want the raw words with minimal formatting (commands, keyword search, real-time captions).
  • SpeechDetector — detects voice activity in the stream.

There’s also DictationTranscriber when you want full transcription with punctuation, sentence structure, and conversational formatting (writing a note or document). Pick SpeechTranscriber for raw text, DictationTranscriber for polished prose.

The key architectural win: it’s fully on-device. Apple’s benchmark notes the legacy SFSpeechRecognizer “sends audio to Apple’s servers by default.” SpeechAnalyzer doesn’t — which matters for privacy, offline use, and latency.

2. Why switch from Whisper: the benchmark

An independent test (get-inscribe, all engines forced fully on-device on an M2 Pro) measured word error rate (lower is better):

EngineClean speech (WER)Noisy speech (WER)Speed
SpeechAnalyzer2.12%4.56%~3× faster than Whisper Small
Whisper Small3.74%7.95%baseline
Whisper Base5.42%12.51%—
Whisper Tiny7.88%17.04%—
SFSpeechRecognizer (legacy)9.02%16.25%—

Read honestly: on this test, SpeechAnalyzer beat every Whisper size tested and the old Apple API, on both clean and noisy audio, while running ~3× faster than Whisper Small. It’s also a massive jump over the legacy SFSpeechRecognizer (2.12% vs 9.02%).

The caveats matter (the benchmark authors flag them): English-only, read audiobook speech (not messy meeting audio or heavy accents), a single M2 Pro, and Whisper was run via CoreML quantization rather than a reference GPU build. So treat it as “strong on clean English on Apple silicon,” not “universally beats Whisper everywhere.” Still — for on-device English transcription in an Apple app, that’s exactly the workload most apps have.

3. The code: transcribe with SpeechAnalyzer

Here’s the real flow (Swift, from Apple’s docs and WWDC sample code).

Create the transcriber and analyzer

import Speech

let transcriber = SpeechTranscriber(
    locale: Locale.current,
    transcriptionOptions: [],
    reportingOptions: [.volatileResults],   // stream partial results as they form
    attributeOptions: []
)

let analyzer = SpeechAnalyzer(modules: [transcriber])

.volatileResults is what gives you live, updating partial text (the words that refine as more audio arrives) instead of only final results.

Pick the right audio format

let analyzerFormat = await SpeechAnalyzer.bestAvailableAudioFormat(
    compatibleWith: [transcriber]
)

Convert your microphone/file buffers to this format before feeding them in.

Make sure the language model is installed

The on-device model for a locale may need downloading once. Use AssetInventory:

// Is this locale supported / already installed?
let supported = await SpeechTranscriber.supportedLocales
let installed = await SpeechTranscriber.installedLocales

// Request download if needed
if let request = try await AssetInventory.assetInstallationRequest(
    supporting: [transcriber]
) {
    try await request.downloadAndInstall()
}

This is the step people miss — without the asset, transcription silently does nothing for that locale.

Stream audio in and start

let (inputSequence, inputBuilder) = AsyncStream<AnalyzerInput>.makeStream()

try await analyzer.start(inputSequence: inputSequence)

// For each converted audio buffer from your engine:
inputBuilder.yield(AnalyzerInput(buffer: convertedBuffer))

Read results as they come

for try await result in transcriber.results {
    let text = String(result.text.characters)   // result.text is an AttributedString
    let isFinal = result.isFinal
    // update your UI: volatile (isFinal == false) vs finalized (true)
}

result.text is an AttributedString (so you can style/inspect ranges), and result.isFinal tells you whether this is a settled result or a still-updating volatile one.

Finalize cleanly

inputBuilder.finish()
try await analyzer.finalizeAndFinishThroughEndOfInput()

Don’t skip finalizeAndFinishThroughEndOfInput() — it flushes the last audio through and emits the final results. The benchmark authors specifically called out that missing this call was a bug in their first implementation (you lose the tail of the transcript).

4. When Apple wins, when Whisper still wins

Match the tool to the job honestly:

Use SpeechAnalyzer when:

  • You’re on iOS 26 / macOS 26 and can require it.
  • You want on-device, private, offline transcription with no server round-trip.
  • Your audio is English or one of the ~30 supported locales.
  • You want the best accuracy + speed for that case and zero model-bundling — Apple ships and updates the model.

Stick with Whisper when:

  • You need broad language coverage — Whisper handles 100+ languages; SpeechTranscriber currently supports ~30 locales.
  • You need cross-platform (Android, web, Linux servers) — SpeechAnalyzer is Apple-only.
  • You’re doing batch server-side transcription at scale rather than on-device.

The honest summary: for on-device transcription inside an Apple app, in a supported language, SpeechAnalyzer is now the default choice — better numbers than Whisper Small, faster, private, and nothing to bundle. Whisper remains the answer when you need languages Apple doesn’t cover or you’re not on Apple platforms.

The takeaway

Apple’s SpeechAnalyzer (with SpeechTranscriber) in iOS 26 / macOS 26 turns on-device speech-to-text into a first-class, private, no-bundle option that — in an independent English benchmark — beat Whisper Small (2.12% vs 3.74% WER) at ~3× the speed. The flow is small: build a SpeechTranscriber, wrap it in a SpeechAnalyzer, ensure the locale model via AssetInventory, stream AnalyzerInput buffers, read transcriber.results, and finalize with finalizeAndFinishThroughEndOfInput(). Reach for it on Apple platforms in a supported locale; keep Whisper for its 100+ languages and cross-platform reach.

For more on-device AI you can ship, see running NuExtract 3 locally, the Qwen3-VL document-extraction pipeline, and running Ornith-1.0 locally.

Sources