Audit an app's network access

Audit an app's network access. Teach readers to inspect which servers an app contacts and what data it sends, using on-device tools and Android's network permissions.

Audit an app's network access | Android App Safety Guide: Android alapú Operáció Rendszer diagram hungarian
Audit an app's network access | Android App Safety Guide AlmásLé , CC BY-SA 4.0 via Wikimedia Commons

When you install an Android app, the system grants the android.permission.INTERNET capability automatically. It is a normal-level permission that cannot be toggled off in the app’s settings screen. That means the question is not “does this app use the network?” but “which servers does it talk to, and what does it send?” To audit an app’s network access, you need tools that work on your device without rooting it, and a decision rule for what to do when you find something unexpected.

Before you start: what network access actually means

Every Android app runs inside a sandbox, but the sandbox does not block the network. The manifest tells you a binary answer: an app either has network access or it does not. It does not tell you which domains the app may contact, what data leaves the device, or whether the link is encrypted. You have to observe the app’s behaviour.

Understand what network access means on Android

When an app holds the INTERNET capability, it can open outgoing links to any host. That is normal for almost every app that syncs, downloads ads, or checks for updates. The absence of the capability does not mean the app cannot send data: some apps use privileged APIs or the system’s own components to transfer data on their behalf, but those cases are rare outside system apps.

What you can actually inspect on a stock Android device:

  • App info screen, lists INTERNET and other network-related entries.
  • Data usage per app, Settings > Network & internet > Data usage shows how much data an app has used, but not where it went.
  • Play Protect, scans apps, but does not show a network log.
  • Developer options, can show active network links, but only while the screen is on and often only for the current foreground process.

None of these tell you which servers an app actually contacts. To answer that, you need a local VPN-based monitor or a packet capture on a machine you control. The method below works on a normal, unrooted phone.

Why declared capabilities are not the whole answer

The INTERNET entry is the single gate for most network access on Android. Once an app has it, the system does not ask again, and the entry does not distinguish between a link to a developer’s server and a link to an ad tracker. You can see that an app can go online, but you cannot see where it goes.

That is why the practical audit has two parts:

  1. Capability inspection, confirm the app has the INTERNET privilege and see what else it asks for.
  2. Data inspection, watch what the app actually sends and to which hosts.

The second part matters more. An app can use the INTERNET capability for completely legitimate features, while a separate SDK inside the same app phones home to a tracker. You will not find that by reading the capability list alone.

How to audit an app’s network access: a step-by-step method

What you need before you start

You do not need root, but you do need a way to capture and inspect network data. The two realistic options for an unrooted phone are:

  • A per-app VPN-based monitor (for example, a local VPN that logs links). These apps create a VPN loop on the device and log the hosts each app contacts.
  • A proxy with TLS inspection (for example, a proxy tool running on a computer, with the phone’s data routed through it). This requires installing a CA certificate on the device, which Android treats as a user certificate. Many apps use certificate pinning, which will break the link or make the app refuse to work. Plan for that.

The VPN-based option is the lower-friction starting point. It will give you a list of hostnames per app, which is usually enough to spot a tracker or a suspicious domain.

Step 1: check the app’s declared capabilities

Open Settings → Apps, find the app, and tap the info entry. Look for:

  • Internet, if this is missing, the app cannot make network links at all, and the rest of the audit is moot.
  • Location, Microphone, Camera, Contacts, Storage, compare these against the app’s core function. A calculator asking for location is a warning. A maps app asking for location is not.

Record the capabilities before you open the app. Some apps request privileges only on first launch, and some can silently gain them through an app update.

Step 2: record the app’s baseline behaviour

Launch the app once, with the VPN-based monitor running, and let it sit on its home screen for about 30 seconds. Then use the monitor’s per-app log to see what hosts it contacted during that time. This is the “idle” baseline.

Then use the app normally for a few minutes. Open the screens you would normally use. Then check the log again.

The difference between the two lists is the app’s “active” behaviour. You are looking for:

  • Hostnames that are not related to the app’s function.
  • Hostnames that look like advertising or analytics domains.
  • Links to domains that have no obvious purpose for the app.

Step 3: identify the hosts

You will typically see a mix of:

  • First-party domains, owned by the app developer (for example, api.example.com).
  • Third-party domains, owned by someone else (for example, doubleclick.net, crashlytics.com, mixpanel.com).

Third-party domains are not automatically malicious. Many apps use analytics and crash-reporting SDKs that are included by default. But the more third-party domains an app contacts, the more data leaves the device, and the less control you have over where it goes.

If you see a domain you do not recognise, search for it. A legitimate domain will have documentation and a clear purpose. A domain with no documentation, or a domain that is registered recently, is worth treating as suspicious.

Step 4: check the app’s signature and update channel

Once you know an app is sending data somewhere you are not comfortable with, the next question is whether you can trust the source you installed it from.

On Android, an app’s signature is what the system uses to verify that an update comes from the same developer. It is not proof of identity. A self-signed certificate only proves that the same key signed the update, not that the developer is who they say they are. But it does tell you whether the app you have installed is the same app that was originally published.

If you installed from an official store, the store has already done some verification. If you installed from a third-party site or an aggregator, you are relying on that site’s own checks. The practical question is:

  • Did you install from the official store for that app?
  • If not, does the site you used verify signatures against the original developer key?

Aggregators that verify signatures are more trustworthy than a random forum link, but they are still not the developer. A signature match means the file was signed with the same key, not that the key belongs to the person you think it does.

Step 5: decide what to do

If the audit shows behaviour you are not comfortable with, you have three options:

  1. Uninstall the app. This is the cleanest option. If the app’s core function does not justify the data it sends, removing it is the simplest fix.
  2. Block the links. Some VPN-based monitors allow you to block specific domains per app. This can break the app’s functionality, but it is a legitimate way to stop the worst behaviour without uninstalling.
  3. Look for an alternative. Search for an open-source or privacy-respecting equivalent of the same app, and repeat the audit on that one.

Android app network audit: what the data inspection reveals

When you inspect app network activity on Android, the VPN-based monitor shows you hostnames, not payload contents. That distinction matters because it sets the ceiling on what this method can tell you. A link to api.example.com looks the same whether it carries a simple version check or a detailed device profile. The hostname alone is your primary signal, and you interpret it by asking three questions:

  • Is the domain clearly owned by the app developer?
  • Does the domain name suggest a function the app needs (sync, auth, content delivery)?
  • Does the domain appear in public blocklists or tracker databases?

If the answer to the first two is “no” and the third is “yes,” the link deserves scrutiny. The method does not require you to decrypt anything, which is why it works without root and without installing a custom CA certificate.

How to inspect app network links on an unrooted device

The VPN-based monitor creates a local tunnel that all app data passes through. Because the monitor runs on the same device, it can associate each link with the originating app’s UID. That gives you a per-app log without needing system-level access. The tradeoff is that you see only the destination host and port, not the full URL path or request body.

To get a useful log:

  • Start the monitor before you launch the app, so you capture the initial handshake.
  • Let the app idle for at least 30 seconds before interacting with it, so you can separate startup noise from user-driven activity.
  • Note the timestamp when you start using the app actively, then compare links before and after that point.

Some monitors let you export the log as a CSV or text file. That is useful if you want to search the hostnames later or share the log with someone who can help you interpret it.

Block internet access per app on Android: what works and what does not

Android does not include a built-in toggle to block internet access per app. The INTERNET capability is granted at install time and cannot be revoked through the standard settings interface. That leaves three practical approaches for restricting an app’s network access:

  1. VPN-based firewall apps. These work by routing data through a local VPN that applies per-app blocking rules. The app itself never sees the block; it simply cannot reach the network. This approach works without root and is available on most Android versions.
  2. Private DNS with hostname blocking. Setting a private DNS provider that blocks known tracker domains (such as dns.adguard.com) stops many third-party links at the DNS level. This is not per-app; it applies device-wide, but it reduces the background noise from trackers across all apps.
  3. Root-based firewalls. If the device is rooted, apps like AFWall+ can apply iptables rules directly, giving fine-grained control over which apps can use Wi-Fi, mobile data, or VPN links. This is the most powerful option, but it requires an unlocked bootloader and carries its own security tradeoffs.

For most users, a VPN-based firewall app is the practical choice. It gives per-app blocking without modifying the system, and it can be turned off when not needed. The main limitation is that Android allows only one active VPN at a time, so you cannot run a privacy VPN and a firewall VPN simultaneously unless one of them supports chaining or proxy forwarding.

What blocking can and cannot achieve

Blocking an app’s internet access stops it from sending new data, but it does not delete data the app has already collected. If an app has already uploaded your contacts or location history, cutting its link prevents further uploads, not retroactive cleanup. Blocking also does not stop the app from storing data locally and waiting for a future link; if you ever unblock it, that queued data may go out in a burst.

Some apps handle being blocked gracefully and continue to work offline. Others depend on a live link and will show errors, freeze, or refuse to open. Test the app after applying a block to see whether its core function survives.

Permissions and privacy: reading the capability list as a signal

The app’s declared capabilities are a coarse filter, not a verdict. A flashlight app that asks for internet access and contacts is more suspicious than a messaging app that asks for the same set, because the messaging app has a plausible need for both. The rule is not “fewer capabilities are better” but “each capability should have a visible purpose in the app’s UI or documented function.”

When you review the list, group what you see into three categories:

  • Core-function capabilities: The app cannot do its main job without them. A camera app needs the camera. A navigation app needs location.
  • Convenience capabilities: The app can work without them, but they enable secondary features. A note-taking app that syncs to the cloud needs internet; a local-only note app does not.
  • Unexplained capabilities: The app’s function does not suggest any need for them. A metronome app asking for contacts falls here.

The third category is where you should pause and consider uninstalling or blocking. The first two categories are not automatically safe (an app can misuse a legitimate capability), but they are not warnings by themselves.

What a clean audit does not mean

A clean network log is not a guarantee of safety. An app can:

  • Send data over an encrypted channel that the monitor cannot decrypt (with a VPN-based monitor, you see the hostname, not the content).
  • Wait for a specific event (for example, a purchase or a login) before sending data.
  • Use certificate pinning to hide activity from a proxy.

A clean audit means the app did not send data to suspicious hosts during the time you watched it. It does not mean the app will never send data, and it does not mean the developer will not change the app’s behaviour in a future update.

The limits of this method

This method will not catch everything. The main gaps are:

  • Encrypted data: you see the destination host, but not the payload. The app could be sending data in the body of a legitimate-looking request.
  • Certificate pinning: some apps will refuse to work through a proxy that does not have the right certificate, which means you cannot inspect their activity at all.
  • Delayed transmission: some SDKs batch data and send it later, sometimes when the app is in the background. You may need to leave the monitor running for hours or days to catch everything.
  • OS-level activity: some data is handled by the operating system itself, not by the app, and will not appear in a per-app log.

These limits are why the audit is best used as a screening tool, not as a definitive verdict. It is a way to catch the obvious problems, not a guarantee that the app is safe.

A note on the INTERNET capability

The INTERNET capability is a normal-level permission on Android. That means the system grants it automatically at install time, and the user is not asked to confirm it. You cannot revoke it individually on most Android versions without also breaking other things, and you cannot restrict it per-app in the standard settings.

That is by design. Android assumes that any app that needs network access can have it, and it does not provide a per-app network toggle in the standard UI. If you want to restrict an app’s network access, you need a third-party tool or a firewall app.

Summary checklist

  1. Check the app’s declared capabilities and compare them against the app’s function.
  2. Launch the app with a per-app VPN monitor and record the idle baseline.
  3. Use the app normally and record the active behaviour.
  4. Look for third-party domains, especially advertising and analytics hosts.
  5. Check the signature and the source you installed from.
  6. Decide whether to uninstall, block, or replace the app.
  7. Remember that a clean audit is a snapshot, not a guarantee.