Post cover image

August 12, 2026

Intercepting Flutter Android App Traffic with Burp Suite Using an Android Studio Emulator…

Introduction

By Cyber Mavala

6 min read

Introduction

While performing mobile application security testing, I found that the standard Android system proxy configuration does not always work with Flutter-based applications, because Flutter applications may not use the Android system proxy settings by default.

I initially tried to configure the proxy on an already-running Android Studio Emulator (AVD), but the Flutter application's traffic was not being intercepted as expected.

After troubleshooting, I found that launching the emulator directly from the terminal with the -http-proxy option worked for my setup.

The important step was to completely close the running emulator first and then start the AVD from the terminal with the proxy configuration.

In this blog, I will explain how to configure Burp Suite, launch an Android Studio Emulator with a proxy, verify HTTP/HTTPS interception, and test traffic from a Flutter-based Android application.

Prerequisites

Before starting, make sure you have the following:

  • macOS / Windows
  • Android Studio
  • Android Studio Emulator / AVD
  • Android SDK
  • ADB
  • Burp Suite
  • Flutter-based Android application

You should also have an Android Virtual Device already created in Android Studio.

1. Identify Your Android Studio AVD

First, open Terminal on macOS.

You can list all available Android Virtual Devices using:

~/Library/Android/sdk/emulator/emulator -list-avds
None

For example:

Pixel_7_API_35
Non_Rooted

In my case, the AVD I wanted to use was:

Non_Rooted

Keep the AVD name because we will use it when launching the emulator.

2. Configure Burp Suite

Open Burp Suite and navigate to:

Proxy → Proxy settings → Proxy listeners

Create or verify a proxy listener.

For example:

Bind address: 0.0.0.0
Port: 8082

In my environment, the host machine's IP address was:

192.168.1.138

Therefore, the Burp proxy endpoint was:

192.168.1.138:8082

Make sure Burp is actually listening on this address and port before starting the emulator.

3. Why the Normal Proxy Configuration May Not Work

For a normal Android application, configuring the Android Wi-Fi/system proxy is often sufficient to route application traffic through Burp Suite.

However, Flutter applications can behave differently.

Flutter networking may not always honor the Android system proxy configuration in the same way as applications using standard Android networking APIs.

As a result, you may configure:

Android Proxy
       ↓
Burp Suite

and still not see the Flutter application's traffic in Burp.

This was the issue I initially encountered.

4. My Initial Approach

Initially, I had the Android Studio Emulator already running.

I attempted to configure the proxy while the emulator was running.

However, the Flutter application's requests were still not appearing in Burp Suite.

I also checked the Android proxy setting:

adb shell settings get global http_proxy

The result was:

null

At this point, instead of continuing to modify the already-running emulator, I decided to completely close the emulator and launch it with the proxy configuration directly.

This was the key change that worked in my environment.

5. Completely Close the Emulator

Before launching the AVD with the proxy, make sure the Android Studio Emulator is completely closed.

Do not simply leave the existing emulator running.

Close the emulator window and ensure that the AVD process has stopped.

You can verify connected devices with:

adb devices

If the emulator is still listed, close it completely before proceeding.

6. Launch the Emulator with -http-proxy

Now launch the AVD directly from Terminal.

The general syntax is:

~/Library/Android/sdk/emulator/emulator -avd <AVD_NAME> -http-proxy http://<PROXY_IP>:<PROXY_PORT>

For my environment, the command was:

~/Library/Android/sdk/emulator/emulator -avd Non_Rooted -http-proxy http://192.168.1.138:8082
None

Here:

ParameterValueAVDNon_RootedProxy IP192.168.1.138Proxy Port8082Proxy URLhttp://192.168.1.138:8082

The emulator will now start with the proxy configuration.

7. Verify ADB Connectivity

Once the emulator has started, open another Terminal window and run:

adb devices

You should see something similar to:

List of devices attached
emulator-5554    device

This confirms that ADB can communicate with the emulator.

8. Test HTTP Traffic

Before testing the Flutter application, I recommend first verifying that basic HTTP traffic from the emulator reaches Burp Suite.

Open Chrome inside the Android emulator.

Visit:

http://example.com

Then go to:

Burp Suite → Proxy → HTTP history

You should see the request.

For example:

GET http://example.com/

If the request appears in Burp, the emulator is successfully communicating through the proxy.

9. Test HTTPS Traffic

Next, test HTTPS traffic.

Open Chrome inside the emulator and visit:

https://example.com

Then check:

Burp Suite → Proxy → HTTP history

If HTTPS interception is correctly configured, you should see the request and response.

If you receive a certificate warning or TLS error, you may need to install the Burp Suite CA certificate on the emulator.

10. Install Burp Suite CA Certificate

For HTTPS interception, the emulator needs to trust the Burp Suite CA certificate.

In Burp Suite, export the CA certificate from:

Proxy → Proxy settings → CA certificate

Save the certificate locally.

For example:

burp-ca.der

You can copy it to the emulator using ADB:

adb push burp-ca.der /sdcard/Download/

Then, on the emulator, install the certificate through the Android security settings.

Depending on the Android version, the menu may be similar to:

Settings → Security → Encryption & credentials → Install a certificate → CA certificate

Select the Burp CA certificate.

The exact menu can differ between Android versions and emulator images.

11. Test the Flutter Application

Once Chrome traffic is successfully appearing in Burp, launch the Flutter application.

Perform an action that generates an API request.

For example:

  • Login
  • Logout
  • Submit a form
  • Load a dashboard
  • Retrieve user information
  • Perform an API transaction

Then check:

Burp Suite → Proxy → HTTP history

You should look for requests such as:

POST /api/login
GET /api/user
POST /api/application

The important test is:

Chrome HTTP       → Burp
Chrome HTTPS      → Burp
Flutter HTTP      → Burp
Flutter HTTPS     → Burp

12. What If Chrome Works but Flutter Does Not?

This is an important distinction when testing Flutter applications.

Suppose you get:

Chrome HTTP       → Burp ✅
Chrome HTTPS      → Burp ✅
Flutter HTTP      → Burp ❌
Flutter HTTPS     → Burp ❌

This does not necessarily mean that your emulator proxy configuration is incorrect.

It may indicate that the Flutter application is not honoring the Android system proxy or that the application has additional network security controls.

Possible areas to investigate include:

  • Flutter networking implementation
  • TLS certificate validation
  • Certificate pinning
  • Custom HTTP clients
  • Network security configuration
  • Flutter engine/library version

13. Verify the Flutter Library

If you need to identify the Flutter library used by the application, first obtain the APK.

You can locate the installed APK using:

adb shell pm path <package_name>

For example:

adb shell pm path com.example.app

Alternatively, use an APK that you already have.

Decode the APK using Apktool:

apktool d app.apk -o app_decoded

Then search for libflutter.so:

find app_decoded -name "libflutter.so"

You may see:

app_decoded/lib/arm64-v8a/libflutter.so

14. Calculate the MD5 Hash

Calculate the MD5 hash of the Flutter library:

md5sum app_decoded/lib/arm64-v8a/libflutter.so

Example:

a1b2c3d4e5f6...  app_decoded/lib/arm64-v8a/libflutter.so

You can compare this hash against the appropriate libraries available in your libflutter_samples directory.

This can help determine whether the application's Flutter library corresponds to a known version/sample.

15. Check the Emulator Architecture

You can check the architecture of the Android emulator using:

adb shell getprop ro.product.cpu.abi

For example:

arm64-v8a

If the emulator is using ARM64, the relevant Flutter library will generally be:

lib/arm64-v8a/libflutter.so

For other architectures, check the corresponding directory under:

lib/

16. Verify the Proxy Setting

You may also check the Android global proxy setting using:

adb shell settings get global http_proxy

Depending on how the emulator was launched and the Android version, this may return:

null

Even if this happens, don't use this command as the only verification method for the -http-proxy option.

The more practical verification is whether traffic from the emulator actually reaches your Burp Suite listener.

For example:

Android Emulator
       |
       | HTTP/HTTPS
       ↓
192.168.1.138:8082
       |
       ↓
Burp Suite
       |
       ↓
HTTP History

If you can see the emulator's traffic in Burp, the proxy path is working.

17. Troubleshooting

Problem 1: Burp receives no traffic

First verify that Burp is listening:

Proxy → Proxy settings → Proxy listeners

Confirm the listener is active on the expected port.

For example:

0.0.0.0:8082

Then verify the host IP:

ifconfig

Make sure you are using the correct IP address.

Problem 2: Chrome works but Flutter doesn't

If Chrome traffic appears in Burp but Flutter traffic does not, investigate Flutter-specific networking behavior.

The problem may not be the emulator proxy.

Check:

  • Flutter networking
  • Certificate pinning
  • TLS validation
  • Custom HTTP clients
  • Application network security configuration

Problem 3: HTTPS certificate error

If HTTP works but HTTPS fails, verify that the Burp CA certificate is installed correctly.

Test HTTPS first with Chrome before testing the Flutter application.

Problem 4: Emulator is already running

If you are trying to add the proxy to an already-running emulator, close it completely.

Then launch it again:

~/Library/Android/sdk/emulator/emulator -avd Non_Rooted -http-proxy http://192.168.1.138:8082

This was the key step that resolved the issue in my setup.

18. Final Working Command

The command that worked for my environment was:

~/Library/Android/sdk/emulator/emulator -avd Non_Rooted -http-proxy http://192.168.1.138:8082

The important part was not just the -http-proxy parameter, but closing the already-running emulator first and then launching the AVD with the proxy configuration.

Conclusion

Intercepting traffic from Flutter-based Android applications can be slightly different from intercepting traffic from traditional Android applications.

The standard Android system proxy may not always be sufficient for Flutter applications because Flutter networking can behave differently from standard Android networking.

In my case, I initially tried configuring the proxy on an already-running Android Studio Emulator, but the Flutter application's traffic was not appearing in Burp Suite.

The solution was to:

  1. Close the running Android Studio Emulator.
  2. Identify the AVD name.
  3. Configure Burp Suite's proxy listener.
  4. Launch the AVD from Terminal using -http-proxy.
  5. Verify HTTP traffic using Chrome.
  6. Verify HTTPS traffic after installing the Burp CA certificate.
  7. Test the Flutter application.
  8. If necessary, analyze libflutter.so and compare its MD5 hash.

The key command was:

~/Library/Android/sdk/emulator/emulator -avd Non_Rooted -http-proxy http://192.168.1.138:8082

Key takeaway: When testing Flutter applications on an Android Studio Emulator, if the normal proxy configuration does not work, try completely closing the emulator and launching the AVD from the terminal with the -http-proxy option. This approach worked for my testing environment.