Skip to content
Back to search

Android-MCP

MCP Server for interacting with Android Devices.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/CursorTouch/Android-MCP with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/CursorTouch/Android-MCP'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/cursortouch--android-mcp/badge.svg)](/listings/cursortouch--android-mcp)

HTML

<a href="/listings/cursortouch--android-mcp"><img src="/api/listings/cursortouch--android-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

📦 Prerequisites

- Python 3.13 - ADB (Android Debug Bridge) - Android 10+ (Emulator/ Android Device)

📲 Testing ADB Connection

Before running the server, ensure your Android device is connected and recognized by ADB:

1. Connect your Android device via USB or ensure your emulator is running. 2. Open a terminal and run:

   adb devices

3. You should see your device listed:

   List of devices attached
   R38M30XXXXX   device

The serial number will differ per device. Emulators show serials like `emulator-5554`. If the list is empty or shows "unauthorized", check your USB debugging settings on the device.

For WiFi ADB, connect the device first:

adb connect 192.168.1.3:5555
adb devices

🏁 Getting Started

You can run the Android MCP server using **UVX** (recommended) or **UV** (for local development).

Option 1: UVX (Recommended)

No need to install dependencies manually. Just configure Claude Desktop:

> **Windows note:** Use Python 3.13 for `uvx` on Windows. Python 3.14 currently fails to resolve a transitive `pywin32` dependency used by the MCP stack.

1. **Locate your config file** - Windows: `%APPDATA%\Claude\claude_desktop_config.json` - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`

2. **Add the configuration**

   {
     "mcpServers": {
       "android-mcp": {
         "command": "uvx",
         "args": [
           "--python",
           "3.13",
           "android-mcp"
         ]
       }
     }
   }

> **Note:** The server starts first and connects lazily when a tool runs. If no device is specified, it auto-detects connected devices and **prefers physical devices over emulators**. Use `--device <serial>` or the `ANDROID_MCP_DEVICE` environment variable to target a specific device.

Configure a specific WiFi device with environment variables:

   {
     "mcpServers": {
       "android-mcp": {
         "command": "uvx",
         "args": [
           "--python",
           "3.13",
           "android-mcp"
         ],
         "env": {
           "ANDROID_MCP_CONNECTION": "wifi",
           "ANDROID_MCP_HOST": "192.168.1.3"
         }
       }
     }
   }

Or pass explicit flags:

   {
     "mcpServers": {
       "android-mcp": {
         "command": "uvx",
         "args": [
           "--python",
           "3.13",
           "android-mcp",
           "--wifi",
           "192.168.1.3"
         ]
       }
     }
   }

Option 2: UV Mode (Local Development)

1. **Clone and Install**

   git clone https://github.com/CursorTouch/Android-MCP.git
   cd Android-MCP
   uv sync

2. **Configure Claude Desktop**

   {
     "mcpServers": {
       "android-mcp": {
         "command": "uv",
         "args": [
           "--directory",
           "</PATH/TO/Android-MCP>",
           "run",
           "android-mcp"
         ]
       }
     }
   }

> **Note:** Replace `</PATH/TO/Android-MCP>` with the full path to your cloned directory. You can also add `"--device", "<YOUR_DEVICE_serial>"`, `"--wifi", "192.168.1.3"`, or `"--usb"` to control device selection. > `uv sync` follows the repo's `.python-version`, so local development uses Python 3.13 by default.

Option 3: OpenCode

You can also use Android-MCP with [OpenCode](https://opencode.ai). After cloning and installing the repo (see Option 2), add the server as a local MCP in your OpenCode config (`opencode.json`):

{
  "mcp": {
    "android-mcp": {
      "type": "local",
      "command": ["uv", "--directory", "</PATH/TO/Android-MCP>", "run", "android-mcp"]
    }
  }
}

> **Note:** Replace `</PATH/TO/Android-MCP>` with the full path to your cloned directory. As with UV mode, you can append `"--device"`, `"--wifi"`, `"--usb"`, etc. to the `command` array to control device selection.

🔌 Device Selection

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 103 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # android-mcp-beta
  2. Clean-room reimplementation of [Android-MCP](https://github.com/CursorTouch/Android-MCP): an MCP
  3. server that lets an AI agent operate an Android device over ADB.
  4. It needs only `adb`. Nothing is installed on the device, and there is no dependency on
  5. uiautomator2.
  6. ## Run
  7. Requires Python 3.13 and `adb` (Android platform-tools).
  8. ```
  9. uv run android-mcp-beta
  10. ```
  11. The server speaks MCP on stdio. In a client's config:
  12. ```json
  13. {
  14. "mcpServers": {
  15. "android-mcp-beta": {
  16. "command": "uv",
  17. "args": ["--directory", "D:/Projects/android-mcp-beta", "run", "android-mcp-beta"]
  18. }
  19. }
  20. }
  21. ```
  22. The device is connected on the first tool call, so the server starts whether or not one is
  23. attached yet.
  24. ## Choosing the device
  25. With no options it uses the first physical device, or an emulator when there is none.
  26. | Option | Environment | Meaning |
  27. |---|---|---|
  28. | `--device SERIAL` | `ANDROID_MCP_DEVICE` | A serial, or `host:port` for a device on the network |
  29. | `--connection auto\|usb\|wifi` (alias `--transport`) | `ANDROID_MCP_CONNECTION` | How to pick when no device is named |
  30. | `--wifi [HOST]` | `ANDROID_MCP_HOST` | ADB over Wi-Fi; `HOST` or `HOST:PORT`, port 5555 by default |
  31. | `--usb [SERIAL]` | | ADB over USB, optionally a specific serial |
  32. Options win over the environment. Other variables:
  33. - `ANDROID_MCP_ADB_PATH` names the `adb` binary. Otherwise `adb` is looked for on `PATH`, then in
  34. `ANDROID_HOME`, `ANDROID_SDK_ROOT` and the default Android Studio SDK folders.
  35. - `SCREENSHOT_QUANTIZED=true` reduces screenshots to 256 colours, which makes them smaller.
  36. ## Tools
  37. | Tool | Does |
  38. |---|---|
  39. | `ListDevices`, `ConnectDevice`, `Device` | List, choose, or disconnect the device |
  40. | `Snapshot` | The interactive elements, each with a label and tap coordinates. `use_vision` adds a screenshot with the labels drawn on it; `use_annotation=false` leaves it clean |
  41. | `Click`, `LongClick`, `Swipe`, `Drag` | Touch input by coordinates |
  42. | `ClickBySelector` | Tap an element found by `text`, `resourceId`, `className` or `description` (exact match; `resourceId` may be the part after the slash), with `index` for the nth match |
  43. | `Type` | Type into a field. `x` and `y` tap it first; `clear` empties it first. Other scripts and emoji need the optional ADBKeyboard app (below) |
  44. | `Press` | A button: back, home, recent, volume up, enter, and so on |
  45. | `Notification` | Pull down the notification shade |
  46. | `Wait`, `WaitForElement` | Pause, or wait for an element to appear |
  47. ## Typing other scripts (optional)
  48. `Type` uses `adb shell input text`, so on its own it types printable ASCII and the accented Latin
  49. letters Android can compose (é ñ ü ÿ and 107 others, not ç ß å ø). A newline presses Enter and a
  50. tab presses Tab. For anything else (CJK, Cyrillic, Arabic, emoji, ç), install the
  51. [ADBKeyboard](https://github.com/senzhk/ADBKeyBoard) app on the device once:
  52. ```
  53. adb install keyboardservice-debug.apk
  54. ```
  55. Download it from the [releases page](https://github.com/senzhk/ADBKeyBoard/releases). This project
  56. does not bundle it: ADBKeyboard is GPL-2.0, and it is only ever talked to over broadcasts. I tested
  57. v2.5-dev (SHA-256 `41a8a099…46fbbb`) on Android 15.
  58. With it installed, text that `input text` cannot type is sent through it automatically. For about
  59. a second the device's keyboard is switched to ADBKeyboard, which shows no keyboard of its own, and
  60. then the keyboard that was active before is put back (and ADBKeyboard is disabled again if it was
  61. not enabled). A text field must be focused, or the call fails with an error saying so. If a crash
  62. ever leaves the device on ADBKeyboard, `adb shell ime reset` restores the default. Without the app,
  63. such text is rejected before anything is sent, with these instructions in the error.
  64. ## Other limits
  65. - **Busy screens.** The element list comes from `uiautomator dump`, which gives up when the screen
  66. never goes idle (a video, a running timer). `Snapshot` with `use_vision` then returns the
  67. screenshot alone and says so; click by coordinates still works.
  68. - **Drag** needs Android 8 or later. **Clearing a field** uses `input keycombination`, which needs
  69. Android 12; older devices fall back to a slower method that clears up to 200 characters.
  70. ## Development
  71. ```
  72. uv sync
  73. uv run pytest
  74. uv run ruff check . && uv run ruff format --check .
  75. ```
  76. The tests need no device. Layers, bottom to top: `android_mcp.adb` (talks to `adb`),
  77. `android_mcp.tree` (reads the screen), `android_mcp.mobile` (one connected device: state and
  78. actions), `android_mcp.server` (the MCP tools and the choice of device).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.