The question is not just “does it work offline?”
You photograph a page from an insurance letter at a pharmacy abroad. The translation appears while your phone is in airplane mode, so you conclude that the document never leaves the device. That test tells you something useful: this particular task completed while ordinary network access was unavailable. It does not tell you what the app sent before the test, whether another feature uses a remote service, what was stored locally, or what happens to the image or text after the phone reconnects.
Translation privacy is a data-flow question. The same app can handle typed text, camera images, speech, downloaded language files, account features, and sharing through different components. A local model can remove the need to transmit user content to a remote inference server for that inference step. It does not prove that the whole app makes no other network requests. Treat “offline,” “on-device,” and “private” as separate claims to check.
Start with a threat model
Before testing, decide what you are trying to protect and from whom. For a travel translation app, sensitive content might include a passport number visible next to a sign, a prescription label, a bank notice, a spoken name, or a bystander’s conversation in the background. The risks may include sending raw text or images to a translation endpoint, retaining history in an account, synchronizing data through device backup, exposing content through logs or notifications, or sharing a result with the wrong app.
This is not a claim that any named translator does those things. It is a checklist of possible paths. The privacy policy, app-store data disclosure, permission prompts, and observed behavior can answer different parts of the question. No single indicator proves the entire system is private. In particular, a denied permission can rule out only the access controlled by that permission; it cannot explain all network traffic or data already collected.
Three translation approaches, three evidence questions
| Approach | What may happen to the translation input | Evidence to check |
|---|---|---|
| Remote translation service | If the selected feature sends input to a remote service, the service processes the submitted text, image, or audio under its documented terms. | Identify the exact feature and provider; read its current privacy and retention disclosures and check whether raw media or extracted text is transmitted. |
| Downloaded offline language feature | A supported task may continue without a connection after required language resources are downloaded. Other app features and later network behavior remain separate questions. | Confirm which language pair and mode are covered; record when resources are fetched and repeat the task after reconnecting. |
| Local model inference | The model can perform its inference step on the device, removing the need to send that content to a remote inference server for that step. | Verify the model path and app behavior; inspect downloads, analytics, account services, backups, crash reporting, and sharing separately. |
The distinctions matter. Google documents that downloaded languages enable specified offline text and camera translation on Android. That describes those workflows; it is not a universal statement about every language, feature, or later request from the app. A network connection used to download resources is also different from a translation request. Read the Google Translate offline instructions for the exact modes and language coverage Google documents.
A realistic scenario: translating a pharmacy label
Suppose you need to read dosage instructions while traveling. Use a made-up or redacted sample for an unfamiliar app; do not use an actual prescription or identity document to find out where the app sends content. First check whether the camera translation mode supports your language pair and whether it requires a download. Then test a non-sensitive sample before travel, note the app version and settings, and see what happens when you restore connectivity.
Even if the offline test works, it cannot establish what happens to saved history, queued requests, crash diagnostics, or optional synchronization after reconnecting. Nor does a translation result establish that the words were read correctly. For medical instructions, confirm the source text and ask a qualified professional when anything is ambiguous. Privacy checks and translation-quality checks are different tasks.
A step-by-step privacy audit
1. List each feature and the data it uses
Make one row for typed text, camera translation, voice input, conversation mode, history, and sharing. For each, note the language pair, whether an image or audio file is involved, what permissions are requested, and whether the feature works before and after any resource download. Avoid treating “translation” as a single route if the app exposes several modes.
2. Read the app’s disclosures before entering sensitive content
Review the current privacy policy and app-store data disclosure for the exact app and version. Look for the types of data collected, purposes, recipients, retention, deletion, account sync, and third-party SDKs. Android’s privacy checklist treats permission use, data access, storage, and user control as application responsibilities. If a disclosure is unclear, treat the unknown as unresolved rather than filling it in from the app’s “offline” label.
3. Separate setup traffic from translation traffic
On a fresh installation or after clearing app data, record which steps require a connection: account setup, language-resource download, model download, license check, or other preparation. Then distinguish those requests from a new translation task. Use non-sensitive sample text or an invented image. A one-time download does not prove that translation inputs are uploaded, and a successful offline translation does not prove that the app never sends requests.
4. Test a new offline task, mode by mode
After the required resources are ready, disconnect through the device’s normal network controls and try a new task—not a result already in history. Test typed text, camera, and voice separately if you plan to use each one. Note the exact app version, device, language pair, mode, and result. If one mode fails, record that limitation; do not generalize from another mode that did work.
5. Reconnect and observe the next state
Restore connectivity and check the app again. Does it show a sync setting, pending upload, sign-in request, or changed history? Check the app’s privacy disclosures for analytics, crash reporting, and backups as well. For an app you own or a debuggable build, Android Studio’s Network Inspector can show when supported network requests send and receive data. It does not automatically reveal the meaning of every encrypted payload, and inability to inspect a request is not proof that no request occurred. For a consumer app you cannot inspect, use its published disclosures and the controls the app exposes; state what remains unknown.
6. Check local retention, sharing, and deletion
Look for saved translations, image history, clipboard use, export, account sync, and system backup options. Try deleting a non-sensitive test item and see whether it disappears from the app’s visible history. That does not prove copies have been deleted from every backup or server, so use the app’s deletion documentation for those claims. Review the destination before sharing a translation to another app; the recipient then has its own storage and privacy behavior.
Acceptance criteria
Call a translation workflow verified only within a clearly defined scope:
- Feature scope: typed, camera, and voice modes are recorded separately, with the app version, language pair, resource state, and test condition.
- Disclosure scope: the current privacy policy and store disclosure identify data types, purposes, recipients, retention, and third-party components—or the missing details are explicitly marked unknown.
- Network scope: a fresh task is tested offline, then the app is checked after reconnection. Any observed request is classified as far as available evidence allows; the test is not used to claim permanent zero uploads.
- Storage scope: history, exports, backups, and deletion are reviewed separately from inference. Sensitive content is not used as test data in an app whose handling is unresolved.
If any item is unknown, the honest conclusion is “not verified for this feature and version.” Choose a less sensitive sample, another workflow, or written assistance until you can resolve it.
Common mistakes
Treating airplane mode as a complete privacy audit. It checks behavior while disconnected. It does not reveal prior requests, queued events, diagnostics, backups, or what happens after reconnection.
Assuming all translation modes share one backend. Text, camera, voice, and conversation features can use different processing paths. Test only the mode you intend to rely on, and do not extend the result to the others.
Treating a permission toggle as a network monitor. A permission controls a category of device access. It does not list destinations or explain every request the app makes.
Testing with the document you most want to protect. Use invented or redacted examples until the app’s data handling is understood. A test can expose the very content it was meant to protect.
Frequently asked questions
If translation works in airplane mode, does that prove my data is never uploaded?
No. It proves only that the tested task completed while ordinary network access was unavailable. It says nothing by itself about earlier setup requests, other features, stored history, queued events, or behavior after reconnection. Check each part separately.
Does downloading a language pack mean translation is fully private?
No. A download can enable a documented offline mode, but the download itself uses a network connection and other app functions may have separate data paths. Confirm the language pair and feature in official documentation, then test the app you actually use.
Can I tell whether an app is local just by its privacy policy?
A policy tells you what the provider says it collects and how it handles data; it is not a live trace of one task. Combine current disclosures with feature-by-feature testing. If the app or build cannot be inspected, report that limitation instead of treating missing evidence as proof.
Will an on-device model prevent every network request?
No. Local inference removes the need to send content to a remote inference server for that step. An app may still need to download resources or use other network services. Check those paths independently.
Is it safe to translate medical or legal documents locally?
Local processing can reduce the need to transmit document content for inference, but it does not establish the app’s full data handling or guarantee correct translation. Verify the complete workflow and have a qualified person review high-stakes meaning.
Sources and related reading
Android’s privacy checklist covers permissions, data access, disclosures, and user control. Android’s Network Inspector guide explains how developers can inspect supported requests in their own app builds. Google documents the supported workflows for downloaded offline translation on Android. For translation workflow tradeoffs, see the offline translation app guide and travel translator privacy comparison.
Updated September 27, 2026. This guide describes a verification method; it does not certify any named app’s current data handling.