Wireless Debugging - APK Extractor

Overview

Wireless debugging allows you to connect Android devices to APK Extractor over WiFi without a USB cable. This feature requires Android 11 or higher and both devices must be on the same network.

Wireless debugging uses ADB over TCP/IP with TLS encryption and pairing codes for secure connections.

Requirements

Android 11+

Wireless debugging feature is built into Android 11 and newer

Same Network

PC and Android device must be on the same WiFi network

Developer Options

Developer options must be enabled on the device

APK Extractor

Web interface or CLI with ADB configured

Wireless debugging is not available on Android 10 or older. Use USB connection or upgrade to Android 11+.

Enabling Developer Options

If you haven’t enabled Developer Options yet:

Open Settings

Navigate to Settings → About phone (or About tablet)

Tap Build Number

Find Build number and tap it 7 timesYou’ll see a message: “You are now a developer!”

Access Developer Options

Go back to Settings → System → Developer options(On some devices: Settings → Developer options directly)

Wireless Debugging Setup

Method 1: Using APK Extractor Web Interface

Enable wireless debugging on Android

On your Android device:

Go to Settings → Developer options
Enable Wireless debugging toggle
Tap Wireless debugging to open its settings

Get pairing information

Tap Pair device with pairing codeYou’ll see a dialog with:

WiFi pairing code: 6-digit number (e.g., 123456)
IP address & Port: e.g., 192.168.1.100:37891

The pairing code expires after a few minutes. If it expires, tap Pair device with pairing code again for a new code.

Open web interface

In APK Extractor web interface:

Click the ”+” button or “Add Device”
Select the “Wireless Debugging” tab
Enter the pairing information:
- IP Address: 192.168.1.100
- Pairing Port: 37891
- Pairing Code: 123456

Pair the device

Click “Pair”You’ll see: “Successfully paired to 192.168.1.100:37891”

Pairing is now complete! You only need to do this once per device.

Get connection port

Back on the Android device, look at the Wireless debugging screen.At the top, you’ll see:

Device name
IP address & port: e.g., 192.168.1.100:33445

This is the connection port (different from the pairing port). It’s persistent and doesn’t expire as quickly.

Connect to device

In APK Extractor:

Still in the “Wireless Debugging” modal
Enter the connection port: 33445
Click “Connect”

The device appears in the sidebar within seconds!

Method 2: Using CLI

Enable wireless debugging

Same as Method 1, Step 1.

Launch CLI

Run apk-downloader.bat and select [2] Depuración inalambrica (WiFi)

Start pairing

Choose [1] Iniciar vinculación

┌─────────────────────────────────────────────────────┐
│  Paso 1: Emparejamiento                             │
└─────────────────────────────────────────────────────┘

IP del dispositivo: 192.168.1.100
Puerto de vinculación: 37891
Código de vinculación (6 dígitos): 123456

Pairing

The CLI runs adb pair:

adb pair 192.168.1.100:37891 123456

Output:

Emparejando con 192.168.1.100:37891...

Successfully paired to 192.168.1.100:37891

[OK] Emparejamiento exitoso.

Connection

The CLI prompts for the connection port:

┌─────────────────────────────────────────────────────┐
│  Paso 2: Conexión                                   │
└─────────────────────────────────────────────────────┘

Puerto de conexión: 33445

Enter the port from the Android device’s Wireless debugging screen.

Conectando a 192.168.1.100:33445...

connected to 192.168.1.100:33445

[OK] Conectado exitosamente a 192.168.1.100:33445

[OK] Dispositivo guardado para reconexión futura.

Method 3: Manual ADB Commands

For advanced users:

# Step 1: Pair (use 6-digit code from device)
adb pair 192.168.1.100:37891
# Enter pairing code: 123456
# Output: Successfully paired to 192.168.1.100:37891

# Step 2: Connect (use connection port from device)
adb connect 192.168.1.100:33445
# Output: connected to 192.168.1.100:33445

# Verify
adb devices
# Output:
# List of devices attached
# 192.168.1.100:33445   device

Once paired, you only need adb connect for future sessions (pairing persists until device reboot or wireless debugging is toggled off).

Understanding Ports

Wireless debugging uses two different ports:

Pairing Port

Temporary port for initial pairing with code

Used once during pairing
Expires after a few minutes
Format: 192.168.1.100:37891
Shown in “Pair device with pairing code” dialog

Connection Port

Persistent port for actual connection

Used every time you connect
Changes when wireless debugging is toggled or device reboots
Format: 192.168.1.100:33445
Shown at top of “Wireless debugging” screen

Port Workflow

Automatic Saving

When you connect a device wirelessly, APK Extractor automatically saves it to devices.json:

[
  {
    "id": "1678901234567",
    "label": "Google Pixel 6",
    "ip": "192.168.1.100",
    "port": "33445",
    "lastConnected": "2026-03-07T16:45:23.456Z"
  }
]

This allows quick reconnection without pairing again.

The device label is auto-detected (brand + model). You can change it later using custom device naming.

Quick Reconnection

For saved devices, you don’t need to pair again:

Web Interface

Click ”+” or “Add Device”
Go to “Saved Devices” tab
Click “Connect” next to the device

CLI

Main menu → [3] Dispositivos guardados → [C] Conectar:

Dispositivos guardados: 2

[1] Google Pixel 6  (192.168.1.100:33445)
[2] Samsung Galaxy Tab  (192.168.1.101:39021)

Número del dispositivo a conectar [1-2]: 1

Conectando a 192.168.1.100:33445...
connected to 192.168.1.100:33445
[OK] Conectado a Google Pixel 6

Keep Wireless debugging enabled on your device for instant reconnection. No pairing needed!

Port Expiration & Re-pairing

Connection ports change when:

Device reboots
Wireless debugging is toggled off/on
Device switches WiFi networks
Long period of inactivity

If quick reconnection fails:

[!] No se pudo conectar. Los puertos pueden haber caducado.

¿Deseas re-vincular este dispositivo? [S/N]: S

The CLI/web interface guides you through re-pairing:

IP is preloaded - no need to type it again
Get new pairing port + code from device
Enter the new pairing port and code
Get new connection port from device
Enter the new connection port
Connection restored and port updated in devices.json

Connection attempt fails

APK Extractor tries to connect using the saved port but fails.

Re-pair prompt

IP: 192.168.1.100 (no modificable)
Nuevo puerto de vinculación: 41234
Código de vinculación: 654321

Emparejando...
Successfully paired to 192.168.1.100:41234

New connection port

Nuevo puerto de conexión: 35678

Conectando a 192.168.1.100:35678...
[OK] Puertos actualizados.

Saved device updated

The new port (35678) is saved to devices.json for future quick reconnections.

mDNS Auto-Discovery

Android devices advertise wireless debugging via mDNS (multicast DNS) using the service:

_adb-tls-connect._tcp

APK Extractor automatically detects these advertised devices:

// Example mDNS device serial
adb-1A2B3C4D5E6F7G8H-abcdef._adb-tls-connect._tcp

When detected:

Resolves IP address from the mDNS hostname
Fetches device info (brand, model) using getprop
Displays in device list with wireless icon

mDNS discovery is automatic - no manual pairing needed if your network supports mDNS/Bonjour.

Some corporate or public WiFi networks block mDNS. If auto-discovery doesn’t work, use manual pairing instead.

WiFi Debugging API

The web interface uses these API endpoints:

Pair Device

POST /api/adb/pair
Content-Type: application/json

{
  "ip": "192.168.1.100",
  "port": "37891",
  "code": "123456"
}

Response:

{
  "ok": true,
  "output": "Successfully paired to 192.168.1.100:37891"
}

Implementation (server.js:586-596):

app.post('/api/adb/pair', async (req, res) => {
  const { ip, port, code } = req.body;
  if (!ip || !port || !code) {
    return res.status(400).json({ error: 'Faltan campos requeridos' });
  }
  
  const result = await runAdb(`pair ${ip}:${port} ${code}`, null, 30000);
  const success = result.toLowerCase().includes('success');
  res.json({ ok: success, output: result.trim() });
});

Connect Device

POST /api/adb/connect
Content-Type: application/json

{
  "ip": "192.168.1.100",
  "port": "33445",
  "label": "My Pixel 6" // optional
}

Response:

{
  "ok": true,
  "output": "connected to 192.168.1.100:33445"
}

The device is automatically saved with auto-detected brand/model or the provided label.

Security Considerations

TLS Encryption

All wireless debugging traffic is encrypted with TLS

Pairing Codes

6-digit codes prevent unauthorized connections

Same Network Only

Devices must be on the same local network (not internet-accessible)

Disable When Not Needed

Turn off wireless debugging to prevent unauthorized access

Always disable Wireless debugging when not using it. Anyone on your WiFi network could potentially pair with your device if it’s left enabled.

For remote connections over the internet, see the Remote Connection guide using Tailscale VPN.

Troubleshooting

Pairing fails: 'failed to connect'

Causes:

Wrong IP address
Wrong pairing port
Pairing code expired
Firewall blocking

Solutions:

Verify IP and port exactly match the device screen
Get a fresh pairing code (tap “Pair device with pairing code” again)
Disable firewall temporarily to test
Ensure PC and device are on the same WiFi network

Pairing succeeds but connection fails

You’re using the pairing port instead of the connection port.Solution: Look at the main “Wireless debugging” screen (not the pairing dialog) for the connection port.

Device disconnects after a few minutes

Causes:

WiFi power saving
Weak signal
Network switching (WiFi ↔ mobile data)

Solutions:

Disable battery optimization for system services
Move device closer to WiFi router
Disable “Switch to mobile data automatically”
Use USB for long operations

Can't enable Wireless debugging

Android 10 or older: Feature not available, use USB
Developer options disabled: Re-enable by tapping Build number 7 times
Airplane mode: Disable airplane mode
WiFi off: Enable WiFi

mDNS device not appearing

Network blocks mDNS: Use manual pairing
Device not advertising: Restart wireless debugging
Firewall: Allow mDNS (UDP port 5353)
Router settings: Enable mDNS/Bonjour forwarding

Connection port keeps changing

This is normal behavior. The port changes when:

Device reboots
Wireless debugging toggled
WiFi network changes

Solution: Use saved devices for quick reconnection. APK Extractor handles port updates automatically.

Best Practices

Use static IP

Configure your router to assign a static IP to your Android device’s MAC address. This prevents IP changes.

Keep wireless debugging enabled

Leave it enabled only when actively using it. Disable when done for security.

Save devices

Let APK Extractor save devices automatically. You’ll thank yourself later when reconnecting is one click.

USB for large operations

Extracting 50+ apps or large (100+ MB) apps? Use USB for speed and stability.

Next Steps

Remote Connection

Connect to devices over the internet using Tailscale

Device Management

Manage multiple WiFi and USB devices

Saved Devices

Understand devices.json format

Extracting APKs

Extract APKs over WiFi

Wireless API

API reference for pairing and connection

Get Started

Guides

Features

Configuration

​Overview

​Requirements

Android 11+

Same Network

Developer Options

APK Extractor

​Enabling Developer Options

​Wireless Debugging Setup

​Method 1: Using APK Extractor Web Interface

​Method 2: Using CLI

​Method 3: Manual ADB Commands

​Understanding Ports

Pairing Port

Connection Port

​Port Workflow

​Automatic Saving

​Quick Reconnection

​Web Interface

​CLI

​Port Expiration & Re-pairing

​mDNS Auto-Discovery

​WiFi Debugging API

​Pair Device

​Connect Device

​Security Considerations

TLS Encryption

Pairing Codes

Same Network Only

Disable When Not Needed

​Troubleshooting

​Best Practices

​Next Steps

Remote Connection

Device Management

Saved Devices

Extracting APKs

Wireless API

Build docs developers (and LLMs) love

Overview

Requirements

Enabling Developer Options

Wireless Debugging Setup

Method 1: Using APK Extractor Web Interface

Method 2: Using CLI

Method 3: Manual ADB Commands

Understanding Ports

Port Workflow

Automatic Saving

Quick Reconnection

Web Interface

CLI

Port Expiration & Re-pairing

mDNS Auto-Discovery

WiFi Debugging API

Pair Device

Connect Device

Security Considerations

Troubleshooting

Best Practices

Next Steps