Local dictation and cloud cleanup on Mac: where your words go

Alexander Burlis — Mon, 26 Oct 2026 14:57:17 +0000

A Mac dictation app can transcribe audio locally and then send the transcript to a cloud model for cleanup. Check both stages before treating a dictation workflow as local.

Speech recognition and cleanup handle different inputs

Speech recognition converts microphone audio into a transcript. Cleanup takes that transcript and edits it: removing fillers, resolving spoken corrections, or turning a rambling sentence into a readable paragraph.

The two stages can run in different places:

Local speech recognition, cloud cleanup

Microphone → local speech model → transcript
                                      ↓
                              remote rewrite model
                                      ↓
                                edited text → editor

In that workflow, the cleanup service receives text. Text omits the original sound, including your voice and ambient noise, but it can still include any background speech captured in the transcript. It can also contain the same customer names, incident details, and unreleased plans as the recording.

For a concrete local implementation, whisper.cpp documents on-device inference and Apple Silicon support. For a cloud implementation, OpenAI's file-transcription documentation shows an audio file being sent to its transcription endpoint.

Map the whole route

Here, local means the model runs on this Mac, with cloud fallback disabled. The table assumes separate speech recognition and text-only cleanup. History, diagnostics, and the destination app need separate checks.

Speech recognition	Cleanup	Processing outside this Mac
Local	Off	None required for speech recognition.
Local	Local	None required for either stage once models are available.
Local	Cloud	The cleanup service receives the transcript, instructions, and any supplied context.
Cloud	Off	The speech service receives audio and produces a transcript.
Cloud	Local	The speech service receives audio and produces a transcript; cleanup can then happen locally.
Cloud	Cloud	Audio reaches the speech service; transcript text and any supplied context reach the cleanup service.

Count every recipient. An app maker may relay requests through its servers before they reach a model provider. Providing your own API key does not prove the request goes directly to that provider. A model on another computer on your LAN is also outside this Mac. If a service accepts audio and returns polished text in one call, it has audio access during cleanup too.

Check fallback behavior too. If a selected local model is unavailable, an app might fail, ask what to do, or use an enabled cloud fallback. Look for a status showing which model actually handled the recording.

For sensitive work, choose a configuration that visibly stops when local processing is unavailable. An automatic fallback can be convenient when cloud processing is acceptable, provided the setting and the resulting route are clear.

What a text-only cleanup request contains

This fictional cleanup request contains a spoken correction and a prohibition:

{
  "instruction": "Remove fillers and resolve spoken corrections. Preserve prohibitions.",
  "text": "Um move the staging release to Thursday, actually Friday, and don't run the migration on production."
}

The desired edited version is:

Move the staging release to Friday. Do not run the migration on production.

Those two details give you specific checks for the cleanup result: keep Friday and preserve the prohibition. Sending the request also discloses the release details to the cleanup service, even though no audio is attached. If the application adds a window title, selected text, or surrounding document content, those fields disclose more than the words you dictated.

Review each recipient's current retention and training terms separately; the word “cloud” does not establish either policy.

Checks you can make in macOS

For Apple's built-in Dictation, open System Settings → Keyboard → Dictation. With Dictation enabled, read the processing notice. Apple says it identifies whether general-text voice input and transcripts are processed on your device and not sent to Siri servers. That description excludes dictation into search boxes. Audio sharing is a separate choice under Privacy & Security → Analytics & Improvements → Improve Siri & Dictation.

If you use Apple Intelligence for cleanup, it can run on device or use Private Cloud Compute for more complex requests. On supported Macs, Privacy & Security → Apple Intelligence Report → Export Activity produces a JSON report of Private Cloud Compute requests. Apple documents a 15-minute or seven-day reporting window. This report covers that Apple service, not every third-party model or network request.

For third-party dictation tools, review Privacy & Security → Accessibility. Apple describes this permission as allowing an app to access and control your Mac. Check what the app says it reads. If it inserts text through copy and paste, also consider clipboard-history tools and Universal Clipboard, which can make copied content available on your other Apple devices.

Check offline behavior with a harmless recording

Use downloaded models and a harmless sentence to check a chosen configuration:

While online, finish setup and download the local models you intend to use.
Select local speech recognition. Turn cleanup off for the first check, and disable cloud fallback if the app offers it.
Open a local, unsynced document. Disconnect Wi-Fi and any other active internet connection.
Dictate the staging-release sentence from the example. Check that the transcript appears and can be inserted or copied.
If you want local cleanup, enable its downloaded model and repeat. Check that the final day is Friday and the prohibition on running the migration survives.

If transcription succeeds but cleanup fails offline, inspect the cleanup route and model readiness separately. A sign-in or license check can also create a network dependency; an offline failure alone does not reveal what content would be sent.

A successful offline run establishes that this configuration can complete that sample without an internet connection. It does not prove that the app never uploads content when connectivity returns.

For an online check, use another harmless recording and watch the app's own row in Activity Monitor → Network before, during, and after dictation. The totals at the bottom cover the whole Mac. The built-in nettop command also shows per-process sockets; press e to expand connections and q to quit.

Include the app's helpers and system background transfers in your investigation. Background URLSession transfers run in a separate system process; on macOS, nsurlsessiond handles them. That daemon can serve multiple apps, so its traffic alone cannot identify which app sent data. A quiet app row does not prove nothing was sent.

These tools can identify connections and data transfer. They cannot tell you whether a TLS-encrypted request contains audio, text, diagnostics, or a mixture. Traffic volume alone cannot settle that question. Confirm payload contents through documented request schemas or a controlled inspection using synthetic content. Check for deferred uploads after reconnecting as well.

Follow the text into its destination

Even when speech recognition and cleanup run locally, inserting the result into a synced note, webmail draft, or team chat can send it through that application's services. Local inference controls one part of the journey.

Dictating into a cloud coding agent is another example. The destination already sends text to its model service; a separate cloud cleanup service can add another recipient.

Keep these checks separate:

Inference: Which services receive audio, text, or added context?
History: Does the dictation app retain recordings or transcripts, and where?
Diagnostics: Can reporting include content, or only operational metadata?
Destination: Will the receiving app save, sync, or send the inserted text?

For source code and shell commands, review exact names, flags, numbers, and negations after any cleanup. Keep automatic submission disabled while checking a terminal workflow: insertion and execution are separate actions.

If you build a dictation tool, expose the speech, cleanup, and fallback routes separately. Send only the context a feature needs. With Apple's Speech framework, check the recognizer's supportsOnDeviceRecognition before requiring local processing with requiresOnDeviceRecognition. Apple documents that the request honors that requirement only when on-device recognition is supported. If your feature promises local processing and support is unavailable, stop visibly.

For a local workflow, start with local speech recognition and cleanup off. Enable a downloaded cleanup model when you need its edits. Check fallback and destination sync before using sensitive content.

Disclosure: This article was generated by an AI assistant. The diagram, payload, and editing example are illustrative; they do not report a benchmark or a hands-on test.